Deploy: Versión inicial con modelos v4

main.py

@@ -0,0 +1,118 @@
+import streamlit as st
+import pandas as pd
+from PIL import Image
+import sys
+import os
+
+# Configuración de rutas
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '/src')))
+from inference import MemePredictor
+
+# --- 1. CONFIGURACIÓN DE PÁGINA (Minimalista) ---
+st.set_page_config(
+    page_title="DIME-MEX",
+    layout="centered",
+    initial_sidebar_state="collapsed"
+)
+
+# --- 2. ESTILOS CSS PERSONALIZADOS (Para móvil) ---
+st.markdown("""
+    <style>
+        /* Ocultar menú hamburguesa y footer para limpieza visual */
+        #MainMenu {visibility: hidden;}
+        footer {visibility: hidden;}
+        
+        /* Ajustar padding para móviles */
+        .block-container {
+            padding-top: 2rem;
+            padding-bottom: 2rem;
+        }
+        
+        /* Botón primario minimalista (Blanco y Negro o color acento del tema) */
+        div.stButton > button:first-child {
+            width: 100%;
+            border-radius: 5px;
+            height: 3em;
+            font-weight: bold;
+        }
+    </style>
+""", unsafe_allow_html=True)
+
+# --- 3. CARGA DEL MOTOR ---
+@st.cache_resource
+def get_engine():
+    return MemePredictor()
+
+try:
+    predictor = get_engine()
+except Exception as e:
+    st.error(f"Error iniciando el sistema: {e}")
+    st.stop()
+
+# --- 4. INTERFAZ DE USUARIO ---
+
+# Título limpio
+st.markdown("## Detector de Contenido")
+st.markdown("Clasificación de memes utilizando visión y lenguaje natural.")
+
+# ACORDEÓN DE CONFIGURACIÓN
+with st.expander("Configuración del Modelo"):
+    task_mode = st.radio(
+        "Nivel de detalle:",
+        options=["simple", "complex"],
+        format_func=lambda x: "Básico (3 Categorías)" if x == "simple" else "Detallado (6 Categorías)"
+    )
+
+# ÁREA DE DRAG AND DROP
+uploaded_file = st.file_uploader("Cargar imagen", type=["jpg", "png", "jpeg"], help="Arrastra tu archivo aquí")
+
+if uploaded_file is not None:
+    # Mostrar imagen centrada y ajustada al ancho del móvil
+    image = Image.open(uploaded_file)
+    st.image(image, use_column_width=True)
+    
+    # Botón de acción (ocupa todo el ancho por el CSS)
+    if st.button("ANALIZAR IMAGEN", type="primary"):
+        
+        with st.spinner("Procesando..."):
+            try:
+                # Inferencia
+                result = predictor.predict(uploaded_file, task=task_mode)
+                
+                if "error" in result:
+                    st.error(result["error"])
+                else:
+                    st.divider() # Línea separadora sutil
+                    
+                    # --- RESULTADOS MINIMALISTAS (st.metric) ---
+                    # Usamos columnas para que se vea bien en celular (uno al lado del otro o apilados)
+                    col1, col2 = st.columns(2)
+                    
+                    with col1:
+                        st.metric(label="Clasificación", value=result['label'])
+                    
+                    with col2:
+                        # Formato de porcentaje limpio
+                        st.metric(label="Confianza", value=f"{result['confidence']:.1%}")
+                    
+                    # Barra de progreso simple
+                    st.progress(result['confidence'])
+                    
+                    # --- DETALLES TÉCNICOS (Ocultos por defecto) ---
+                    with st.expander("Ver texto extraído"):
+                        st.caption("Texto detectado por OCR:")
+                        st.text(result["ocr_text"])
+                        st.caption("Texto procesado para el modelo:")
+                        st.code(result["clean_text"], language="text")
+                    
+                    # --- GRÁFICA LIMPIA ---
+                    st.caption("Distribución de probabilidades")
+                    chart_data = pd.DataFrame({
+                        "Categoría": result['all_labels'],
+                        "Probabilidad": result['probabilities']
+                    })
+                    # Gráfica de barras horizontal es mejor para leer etiquetas largas en móvil
+                    st.bar_chart(chart_data.set_index("Categoría"), color="#333333")
+
+            except Exception as e:
+                st.error(f"Error interno: {e}")

models/beto_complex_v4.pth

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

models/beto_simple_v4.pth

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

packages.txt

@@ -0,0 +1,2 @@
+libgl1-mesa-glx
+libglib2.0-0

requeriments.txt

@@ -0,0 +1,13 @@
+pandas
+numpy
+scikit-learn
+torch
+huggingface-hub<1.0
+transformers
+nltk
+matplotlib
+seaborn
+tqdm
+streamlit
+easyocr
+opencv-python-headless

requirements.txt

@@ -1,3 +0,0 @@
-altair
-pandas
-streamlit

src/directory.py

@@ -0,0 +1,62 @@
+import pandas as pd
+import json
+import os
+
+# Configuracion de rutas dinamicas
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, "../"))
+
+# Directorios de entrada y salida
+INPUT_DIR = os.path.join(PROJECT_ROOT, "data", "train")
+OUTPUT_DIR = os.path.join(PROJECT_ROOT, "data", "processed", "datasets")
+
+TASKS = {
+    "simple": {
+        "file": "label_simple.csv",
+        "cols": ["none", "inappropriate", "hate_speech"] 
+    },
+    "complex": {
+        "file": "label_complex.csv",
+        "cols": ["none", "inappropriate", "sexism", "racism", "classicism", "other"]
+    }
+}
+
+def create_dataset_csv(task_name):
+    # Validar existencia del directorio de entrada
+    if not os.path.exists(INPUT_DIR):
+        print(f"Error: No se encuentra el directorio {INPUT_DIR}")
+        return
+
+    # Cargar archivo JSON con metadatos
+    json_path = os.path.join(INPUT_DIR, "train_data.json")
+    with open(json_path, 'r', encoding='utf-8') as f:
+        data_json = json.load(f)
+    
+    df = pd.DataFrame(data_json)
+    
+    # Cargar archivo CSV con etiquetas
+    csv_conf = TASKS[task_name]
+    labels_path = os.path.join(INPUT_DIR, csv_conf["file"])
+    df_labels = pd.read_csv(labels_path, header=None)
+    
+    # Convertir one-hot encoding a etiquetas numericas
+    df['label'] = df_labels.values.argmax(axis=1)
+    
+    # Generar rutas relativas de las imagenes
+    images_prefix = os.path.join("data", "train", "images")
+    df['path'] = df['MEME-ID'].apply(lambda x: os.path.join(images_prefix, x))
+    
+    # Seleccionar columnas finales
+    final_df = df[['path', 'text', 'description', 'label']]
+    
+    # Crear directorio de salida si no existe
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    # Guardar archivo CSV
+    output_file = os.path.join(OUTPUT_DIR, f"dataset-{task_name}.csv")
+    final_df.to_csv(output_file, index=False)
+    print(f"Archivo generado: {output_file}")
+
+if __name__ == "__main__":
+    create_dataset_csv("simple")
+    create_dataset_csv("complex")

src/inference.py

@@ -0,0 +1,137 @@
+import torch
+import easyocr
+import os
+import sys
+from transformers import AutoTokenizer
+
+# Configurar path para importar módulos locales (nlp_utils y utils)
+CURRENT_DIR = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(CURRENT_DIR)
+
+from nlp_utils import BetoClassifier
+from utils import clean_text, preprocess_image_for_ocr
+
+# ==========================================
+# ⚙️ CONFIGURACIÓN DEL MODELO
+# ==========================================
+MODEL_VERSION = "v4"  # <--- CAMBIA ESTO si entrenas nuevas versiones
+MODEL_NAME = "dccuchile/bert-base-spanish-wwm-cased"
+MAX_LEN = 128
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Construcción de la ruta: .../DIMEMEX/models/v4/
+# Subimos dos niveles desde src/inference.py para llegar a la raiz, luego models, luego v4
+PROJECT_ROOT = os.path.abspath(os.path.join(CURRENT_DIR, "../"))
+MODEL_DIR = os.path.join(PROJECT_ROOT, "models")
+
+class MemePredictor:
+    def __init__(self):
+        print(f"🔧 Inicializando motor en: {DEVICE}")
+        print(f"📂 Buscando modelos versión {MODEL_VERSION} en: {MODEL_DIR}")
+        
+        # Cargar OCR (Singleton)
+        self.reader = easyocr.Reader(['es', 'en'], gpu=(DEVICE.type == 'cuda'))
+        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+        
+        # Cache para no recargar modelos .pth
+        self.loaded_models = {}
+        
+        # Mapas de etiquetas
+        self.labels_map = {
+            "simple": ["None", "Inappropriate", "Hate"],
+            "complex": ["None", "Inapp", "Sexism", "Racism", "Classicism", "Other"]
+        }
+
+    def _get_model_instance(self, task):
+        # Si ya está en RAM, devolverlo
+        if task in self.loaded_models:
+            return self.loaded_models[task]
+        
+        # Construir nombre del archivo: beto_simple_v4.pth
+        filename = f"beto_{task}_{MODEL_VERSION}.pth"
+        path = os.path.join(MODEL_DIR, filename)
+        
+        if not os.path.exists(path):
+            raise FileNotFoundError(f"No se encontró el modelo para la tarea '{task}' en {path}")
+
+        print(f"📥 Cargando modelo desde: {path}")
+        
+        n_classes = len(self.labels_map[task])
+        
+        # Instanciar arquitectura
+        model = BetoClassifier(n_classes, MODEL_NAME)
+        
+        # Cargar pesos
+        # map_location es vital para evitar errores si entrenaste en GPU y corres en CPU
+        try:
+            model.load_state_dict(torch.load(path, map_location=DEVICE))
+        except Exception as e:
+            raise RuntimeError(f"Error al leer el archivo .pth: {e}")
+            
+        model.to(DEVICE)
+        model.eval()
+        
+        self.loaded_models[task] = model
+        return model
+
+    def predict(self, image_file, task="simple"):
+        # 1. Resetear puntero del archivo
+        image_file.seek(0)
+        
+        # 2. Pre-procesamiento de Imagen (Visión)
+        proc_img, raw_img = preprocess_image_for_ocr(image_file)
+        
+        if proc_img is None:
+            return {"error": "Error procesando la imagen (archivo corrupto o formato inválido)"}
+
+        # 3. OCR con Fallback
+        try:
+            # Intento 1: Imagen procesada
+            ocr_result = self.reader.readtext(proc_img, detail=0, paragraph=True)
+            raw_text = " ".join(ocr_result)
+            
+            # Si leyó muy poco (<3 chars), intentar con la original
+            if len(raw_text) < 3:
+                ocr_result = self.reader.readtext(raw_img, detail=0, paragraph=True)
+                raw_text = " ".join(ocr_result)
+        except Exception as e:
+            return {"error": f"Fallo en OCR: {e}"}
+
+        # 4. Limpieza de Texto (NLP)
+        text_ready = clean_text(raw_text)
+        
+        # 5. Tokenización
+        encoding = self.tokenizer.encode_plus(
+            text_ready,
+            add_special_tokens=True,
+            max_length=MAX_LEN,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt',
+        )
+        
+        input_ids = encoding['input_ids'].to(DEVICE)
+        attention_mask = encoding['attention_mask'].to(DEVICE)
+        
+        # 6. Inferencia del Modelo
+        try:
+            model = self._get_model_instance(task)
+            
+            with torch.no_grad():
+                outputs = model(input_ids, attention_mask)
+                probs = torch.nn.functional.softmax(outputs, dim=1)
+                conf, idx = torch.max(probs, dim=1)
+                
+            label_str = self.labels_map[task][idx.item()]
+            
+            return {
+                "ocr_text": raw_text,
+                "clean_text": text_ready,
+                "label": label_str,
+                "confidence": conf.item(),
+                "probabilities": probs.cpu().numpy()[0],
+                "all_labels": self.labels_map[task]
+            }
+        except Exception as e:
+            return {"error": f"Error en inferencia del modelo: {e}"}

src/nlp_utils.py

@@ -0,0 +1,46 @@
+# src/nlp_utils.py
+import torch.nn as nn
+from torch.utils.data import Dataset
+import torch
+from transformers import AutoModel
+
+class BetoClassifier(nn.Module):
+    def __init__(self, n_classes, model_name="dccuchile/bert-base-spanish-wwm-cased"):
+        super(BetoClassifier, self).__init__()
+        self.bert = AutoModel.from_pretrained(model_name)
+        self.drop = nn.Dropout(p=0.3)
+        self.out = nn.Linear(self.bert.config.hidden_size, n_classes)
+        
+    def forward(self, input_ids, attention_mask):
+        output = self.bert(input_ids=input_ids, attention_mask=attention_mask)
+        return self.out(self.drop(output.pooler_output))
+
+class MemeDataset(Dataset):
+    def __init__(self, df, tokenizer, max_len, label_col):
+        self.df = df.reset_index(drop=True)
+        self.tokenizer = tokenizer
+        self.max_len = max_len
+        self.label_col = label_col # Columna dinamica segun la tarea
+        
+    def __len__(self):
+        return len(self.df)
+    
+    def __getitem__(self, index):
+        text = str(self.df.loc[index, 'text_clean'])
+        label = int(self.df.loc[index, self.label_col])
+        
+        encoding = self.tokenizer.encode_plus(
+            text,
+            add_special_tokens=True,
+            max_length=self.max_len,
+            padding='max_length',
+            truncation=True,
+            return_attention_mask=True,
+            return_tensors='pt',
+        )
+        
+        return {
+            'input_ids': encoding['input_ids'].flatten(),
+            'attention_mask': encoding['attention_mask'].flatten(),
+            'label': torch.tensor(label, dtype=torch.long)
+        }

src/split-data.py

@@ -0,0 +1,75 @@
+import pandas as pd
+from sklearn.model_selection import train_test_split
+import os
+
+# Configuracion de rutas dinamicas
+SCRIPT_DIR = os.path.dirname(os.path.abspath(__file__))
+PROJECT_ROOT = os.path.abspath(os.path.join(SCRIPT_DIR, "../"))
+
+# Directorios de entrada y salida
+DATA_PROCESSED_DIR = os.path.join(PROJECT_ROOT, "data", "processed","nlp")
+TEXT_FILE_PATH = os.path.join(DATA_PROCESSED_DIR, "cleaned-ocr.csv")
+SIMPLE_FILE_PATH = os.path.join(DATA_PROCESSED_DIR, "datasets", "dataset-simple.csv")
+COMPLEX_FILE_PATH = os.path.join(DATA_PROCESSED_DIR, "datasets", "dataset-complex.csv")
+OUTPUT_DIR = os.path.join(DATA_PROCESSED_DIR, "splits")
+
+def create_master_splits():
+    # Validar existencia de archivos de entrada
+    if not all(os.path.exists(p) for p in [TEXT_FILE_PATH, SIMPLE_FILE_PATH, COMPLEX_FILE_PATH]):
+        print("Error: Faltan archivos de entrada en data/processed")
+        return
+
+    # Cargar archivos CSV
+    df_text = pd.read_csv(TEXT_FILE_PATH)
+    df_simple = pd.read_csv(SIMPLE_FILE_PATH)
+    df_complex = pd.read_csv(COMPLEX_FILE_PATH)
+    
+    # Generar columna id basada en el nombre del archivo si no existe
+    if 'id' not in df_simple.columns:
+        df_simple['id'] = df_simple['path'].apply(os.path.basename)
+    if 'id' not in df_complex.columns:
+        df_complex['id'] = df_complex['path'].apply(os.path.basename)
+
+    # Renombrar columnas de etiquetas para evitar conflictos
+    df_simple = df_simple.rename(columns={'label': 'label-simple'})
+    df_complex = df_complex.rename(columns={'label': 'label-complex'})
+    
+    # Unir etiquetas simples y complejas usando el id
+    df_labels_merged = pd.merge(df_simple, df_complex[['id', 'label-complex']], on='id', how='inner')
+    
+    # Unir con el texto limpio para crear el dataset maestro
+    df_master = pd.merge(df_labels_merged, df_text[['id', 'text_clean']], on='id', how='inner')
+    
+    # Crear directorio de salida si no existe
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # Guardar el dataset completo para entrenamiento final
+    complete_data_path = os.path.join(OUTPUT_DIR, "complete-data.csv")
+    df_master.to_csv(complete_data_path, index=False)
+    print(f"Dataset completo guardado en: {complete_data_path}")
+
+    # Separar conjunto de prueba manteniendo balance de clases complejas
+    df_temp, df_test = train_test_split(
+        df_master, 
+        test_size=0.15, 
+        random_state=42, 
+        stratify=df_master['label-complex'] 
+    )
+    
+    # Separar entrenamiento y validacion del conjunto restante
+    df_train, df_val = train_test_split(
+        df_temp, 
+        test_size=0.176, 
+        random_state=42, 
+        stratify=df_temp['label-complex']
+    )
+    
+    # Guardar los archivos de particion
+    df_train.to_csv(os.path.join(OUTPUT_DIR, "train.csv"), index=False)
+    df_val.to_csv(os.path.join(OUTPUT_DIR, "val.csv"), index=False)
+    df_test.to_csv(os.path.join(OUTPUT_DIR, "test.csv"), index=False)
+    
+    print(f"Splits guardados en: {OUTPUT_DIR}")
+
+if __name__ == "__main__":
+    create_master_splits()

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))

src/utils.py

@@ -0,0 +1,51 @@
+import re
+import cv2
+import numpy as np
+import pandas as pd
+
+def clean_text(text):
+    """Limpieza estándar para BERT."""
+    if not text or pd.isna(text): return "sin texto"
+    text = str(text).lower()
+    # Eliminar URLs y usuarios
+    text = re.sub(r'http\S+|www\.\S+', '', text)
+    text = re.sub(r'@\w+', '', text)
+    # Normalizar risas
+    text = re.sub(r'(ja|je|ha|he|lo){2,}', 'jaja', text)
+    # Eliminar basura de OCR
+    text = re.sub(r'[|_~*^>\[\]]', ' ', text)
+    # Espacios y saltos
+    text = text.replace('\n', ' ').replace('\r', ' ')
+    text = re.sub(r'\s+', ' ', text).strip()
+    return text if text else "sin texto"
+
+def preprocess_image_for_ocr(file_bytes):
+    """
+    Recibe bytes (desde Streamlit) y aplica filtros de OpenCV.
+    Retorna: (imagen_binarizada, imagen_original_cv2)
+    """
+    # Convertir bytes a array numpy para OpenCV
+    file_bytes = np.asarray(bytearray(file_bytes.read()), dtype=np.uint8)
+    img = cv2.imdecode(file_bytes, 1) # 1 = Color BGR
+    
+    if img is None: return None, None
+
+    # Pipeline de Mejora (Igual al benchmark)
+    try:
+        # 1. Upscaling (2x)
+        img_resized = cv2.resize(img, None, fx=2, fy=2, interpolation=cv2.INTER_CUBIC)
+        
+        # 2. Escala de Grises
+        gray = cv2.cvtColor(img_resized, cv2.COLOR_BGR2GRAY)
+        
+        # 3. Denoising
+        denoised = cv2.fastNlMeansDenoising(gray, None, h=10, templateWindowSize=7, searchWindowSize=21)
+        
+        # 4. Binarización Adaptativa
+        binary = cv2.adaptiveThreshold(
+            denoised, 255, cv2.ADAPTIVE_THRESH_GAUSSIAN_C, cv2.THRESH_BINARY, 11, 2
+        )
+        return binary, img
+    except Exception as e:
+        print(f"Error en pre-procesamiento: {e}")
+        return None, img