Upload 14 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+utils/emotions.csv filter=lfs diff=lfs merge=lfs -text

utils/chatgpt_config.py

@@ -0,0 +1,40 @@
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+# Ruta relativa al archivo .env
+dotenv_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), ".env")
+
+# Cargar el archivo .env desde la ruta especificada
+load_dotenv(dotenv_path)
+
+# Leer la clave API
+API_KEY = os.getenv("OPENAI_API_KEY")
+
+client = OpenAI(api_key=API_KEY)
+
+def send_ChatGPT(emotion_face=None, emotion_text=None):
+    # Verificar qué parámetros se proporcionaron
+    if emotion_face and emotion_text:
+        prompt = f"Act like you are a psychologist expert in emotions, i want recommendation of music, fun activities, actions, or advices if the image im receiving shows a {emotion_face} emotion and the text from a chat that the user provide us shows a {emotion_text} emotion"
+    elif emotion_face:
+        prompt = f"i want recommendation of music, fun activities, actions, or advices because im expiriencing a {emotion_face} emotion"
+    elif emotion_text:
+        prompt = f"i want recommendation of music, fun activities, actions, or advices because im expiriencing a {emotion_text} emotion"
+    else:
+        raise ValueError("At least one of 'emotion_face' or 'emotion_text' must be provided.")
+    
+    # Realizar la llamada al modelo
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=[
+            {"role": "user", "content": prompt}
+        ],
+        temperature=0.81,
+        max_tokens=2000,
+        top_p=1,
+        frequency_penalty=0,
+        presence_penalty=0
+    )
+    
+    return response.choices[0].message.content

utils/dataset.py

@@ -0,0 +1,44 @@
+from sklearn.utils import resample
+import pandas as pd
+import re
+import os
+
+file_path=os.path.join(os.path.dirname(__file__),'emotions.csv')
+
+data=pd.read_csv(file_path)
+
+# Ver distribución de clases después de la concatenación
+class_counts = data["label"].value_counts()
+print("Distribución después de la concatenación:")
+print(class_counts)
+
+min_class_count = class_counts.min()
+
+# Balancear el dataset
+balanced_data = pd.concat([
+    resample(data[data["label"] == label], 
+             replace=False,  # No hacer duplicados
+             n_samples=min_class_count,  # Igualar al tamaño de la clase minoritaria
+             random_state=42) 
+    for label in class_counts.index
+])
+
+balanced_data = balanced_data.sample(frac=1, random_state=42)
+
+def clean_text(text):
+    # Paso 1: Remover links completos que contengan http, https, o www
+    text = re.sub(r"(http[s]?://[^\s]+|www\.[^\s]+)", "", text)
+    # Paso 2: Remover caracteres especiales y dejar solo letras, números y espacios
+    text = re.sub(r"[^A-Za-z0-9\s]", "", text)
+    # Paso 3: Eliminar espacios extra
+    text = re.sub(r"\s+", " ", text).strip()
+    return text
+
+balanced_data["text"] = balanced_data["text"].apply(clean_text)
+
+# Mostrar resultados finales
+print("\nDistribución balanceada de clases:")
+print(balanced_data["label"].value_counts())
+
+# Guardar el dataset balanceado
+balanced_data.to_csv("balanced_dataset.csv", index=False)

utils/emotions.csv

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

utils/model1.h5

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

utils/model13.h5

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

utils/modelFace.py

@@ -0,0 +1,92 @@
+from ultralytics import YOLO
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing.image import img_to_array
+
+import cv2
+import numpy as np
+import sys
+import os
+import base64
+
+
+# Función para preprocesar imágenes desde un arreglo
+def preprocess_image_from_array(image, target_size=(256, 256)):
+    img = cv2.resize(image, target_size)  # Redimensionar la imagen
+    img_array = img_to_array(img)  # Convertir a arreglo
+    img_array = np.expand_dims(img_array, axis=0)  # Expandir dimensiones
+    img_array = img_array / 255.0  # Normalizar
+    return img_array
+
+# Función para detectar y recortar el rostro
+def detect_and_crop_face(image, yolo_model, padding=0.1):
+    results = yolo_model(image)
+    boxes = results[0].boxes.xyxy.cpu().numpy()  # Obtener las coordenadas de las cajas
+    confidences = results[0].boxes.conf.cpu().numpy().tolist()  # Obtener las confianzas
+
+    if len(boxes) > 0:
+        max_index = confidences.index(max(confidences))  # Índice de mayor confianza
+        x1, y1, x2, y2 = map(int, boxes[max_index])  # Coordenadas de la caja
+
+        # Calcular el tamaño del padding
+        h, w, _ = image.shape
+        box_width = x2 - x1
+        box_height = y2 - y1
+        pad_x = int(box_width * padding)  # Padding horizontal
+        pad_y = int(box_height * padding)  # Padding vertical
+
+        # Ajustar las coordenadas con padding, asegurándose de no salir de la imagen
+        x1 = max(0, x1 - pad_x)
+        y1 = max(0, y1 - pad_y)
+        x2 = min(w, x2 + pad_x)
+        y2 = min(h, y2 + pad_y)
+
+        # Recortar la cara con padding
+        cropped_face = image[y1:y2, x1:x2]
+        return cropped_face, max(confidences)
+    
+    return None, 0  # No se detectó ninguna cara
+
+
+# Función principal
+def predict_face(img_base64):
+    # Carga del modelo YOLO para detección de caras
+    yolo_model = YOLO(os.path.join(os.path.dirname(__file__), "yolov8m-face.pt"))
+    # Carga del modelo de clasificación
+    emotion_model = load_model(os.path.join(os.path.dirname(__file__), './model13.h5'))
+    # class_names = ["sadness", "happiness", "love", "anger", "worry", "neutral"]
+    class_names = ["anger", "fear", "happy", "neutral", "sad", "surprise"]
+
+    image_data = base64.b64decode(img_base64)
+    np_array = np.frombuffer(image_data, np.uint8)
+
+    # Paso 3: Leer la imagen con OpenCV desde el array NumPy
+    image = cv2.imdecode(np_array, cv2.IMREAD_COLOR)
+
+    if image is None:
+        print("Error: no se pudo cargar la imagen.")
+        return
+    
+    # Detectar y recortar el rostro
+    face, confidence = detect_and_crop_face(image, yolo_model)
+    if face is not None:
+        print(f"Rostro detectado con confianza: {confidence*100:.2f}%")
+        preprocessed_face = preprocess_image_from_array(face)
+
+        # Predicción de emoción
+        prediction = emotion_model.predict(preprocessed_face)
+        print(prediction)
+        predicted_class = np.argmax(prediction)
+        confidence = np.max(prediction)
+        
+        # Mostrar la imagen con la predicción
+        # plt.imshow(cv2.cvtColor(face, cv2.COLOR_BGR2RGB))
+        # plt.title(f"Emoción: {class_names[predicted_class]} ({confidence*100:.2f}%)")
+        # plt.axis("off")
+        # plt.show()
+        return str(class_names[predicted_class])
+    else:
+        print("No se detectó ningún rostro en la imagen.")
+
+# if __name__ == "__main__":
+#     predict_face()

utils/modelText.py

@@ -0,0 +1,54 @@
+from tensorflow.keras.models import load_model
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+
+import numpy as np
+import pickle  # Si deseas guardar/cargar el tokenizer
+import re
+import os
+
+# Carga el modelo entrenado
+model_path = os.path.join(os.path.dirname(__file__),'model_2_texto.h5') # Cambia el número de versión si es necesario
+model = load_model(model_path)
+
+# Etiquetas de emociones (asegúrate de que coincidan con las usadas en el entrenamiento)
+EMOTION_LABELS = {
+    0: 'sadness',
+    1: 'joy',
+    2: 'love',
+    3: 'anger',
+    4: 'fear',
+    5: 'surprise',
+}
+
+# Carga el tokenizer (suponiendo que lo guardaste en un archivo)
+tokenizer_path = os.path.join(os.path.dirname(__file__),'tokenizer.pickle')  # Cambia el nombre si usaste otro
+with open(tokenizer_path, 'rb') as handle:
+    tokenizer = pickle.load(handle)
+
+# Configuración del padding
+MAX_LEN = 100  # Debe coincidir con el valor usado en el entrenamiento
+
+# Función para limpiar el texto
+def clean_text(text):
+    if isinstance(text, str):
+        text = re.sub(r'http\S+|www\S+|https\S+', '', text)
+        text = re.sub(r'@\w+|#\w+', '', text)
+        text = re.sub(r'[^a-zA-Z0-9\s!?.,]', '', text)
+        text = text.lower().strip()
+        return text
+    return ""
+
+# Función para predecir la emoción principal
+def predict_text(text):
+    sequence = tokenizer.texts_to_sequences(text)
+    padded = pad_sequences(sequence, maxlen=MAX_LEN)
+    prediction = model.predict(padded)[0]
+    max_index = np.argmax(prediction)
+    main_emotion = EMOTION_LABELS[max_index]
+    return str(main_emotion)
+
+# Ejemplo de predicción7
+sample_text = 'I hate my stupid dog'
+emotion = predict_text(sample_text)
+print(f"La emoción principal es: {emotion}")

utils/model_2_texto.h5

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

utils/tokenizer.pickle

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

utils/tokenizer1.pkl

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

utils/yolov8m-face.pt

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