Upload 3 files

Dockerfile

@@ -1,5 +1,5 @@
 # Usa una imagen base de Python
-FROM python:3.12.4
+FROM python:3.12.7
 # Establece el directorio de trabajo
 WORKDIR /code
 

app.py

@@ -1,142 +1,43 @@
-from fastapi import FastAPI, HTTPException
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import HTMLResponse
 from pydantic import BaseModel
-import numpy as np
-import random
 from typing import List
+import cv2
+from PIL import Image
+import numpy as np
+from io import BytesIO
 
-class InputData(BaseModel):
-    data: List[float]  # Lista de características numéricas (flotantes)
-    data2: List[float]  # Lista de características numéricas (flotantes)
-    
 app = FastAPI()
 
-# ------------- algoritmo genetico -------------
-# Función para generar una población inicial aleatoria
-def generar_poblacion(num_individuos, num_ciudades):
-    poblacion = []
-    for _ in range(num_individuos):
-        individuo = list(range(num_ciudades))
-        random.shuffle(individuo)
-        poblacion.append(individuo)
-    return poblacion
-
-# Función para evaluar la aptitud de un individuo (distancia total del recorrido)
-def calcular_aptitud(individuo, distancias, coordenadas):
-    distancia_total = 0
-    coordenadas_iguales = all(coord == coordenadas[0] for coord in coordenadas)
-
-    if not coordenadas_iguales:
-        for i in range(len(individuo) - 1):
-            ciudad_actual = individuo[i]
-            siguiente_ciudad = individuo[i + 1]
-            distancia_total += distancias[ciudad_actual][siguiente_ciudad]
-
-        distancia_total += distancias[individuo[-1]][individuo[0]]
-
-    return distancia_total
-
-# Función para seleccionar individuos para la reproducción (torneo binario)
-def seleccion_torneo(poblacion, distancias, coordenadas):
-    seleccionados = []
-    for _ in range(len(poblacion)):
-        torneo = random.sample(poblacion, 2)
-        aptitud_torneo = [
-            calcular_aptitud(individuo, distancias, coordenadas) for individuo in torneo
-        ]
-        seleccionado = torneo[aptitud_torneo.index(min(aptitud_torneo))]
-        seleccionados.append(seleccionado)
-    return seleccionados
-
-# Función para realizar el cruce de dos padres para producir un hijo
-def cruzar(padre1, padre2):
-    punto_cruce = random.randint(0, len(padre1) - 1)
-    hijo = padre1[:punto_cruce] + [
-        gen for gen in padre2 if gen not in padre1[:punto_cruce]
-    ]
-    return hijo
-
-
-# Función para aplicar mutaciones en la población
-def mutar(individuo, probabilidad_mutacion):
-    if random.random() < probabilidad_mutacion:
-        indices = random.sample(range(len(individuo)), 2)
-        individuo[indices[0]], individuo[indices[1]] = (
-            individuo[indices[1]],
-            individuo[indices[0]],
-        )
-    return individuo
-
-# Función para generar distancias aleatorias entre ciudades y sus coordenadas bidimensionales
-def generar_distancias(num_ciudades):
-    distancias = [[0] * num_ciudades for _ in range(num_ciudades)]
-    coordenadas = [
-        (random.uniform(0, 100), random.uniform(0, 100)) for _ in range(num_ciudades)
-    ]
-
-    for i in range(num_ciudades):
-        for j in range(i + 1, num_ciudades):
-            distancias[i][j] = distancias[j][i] = (
-                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
-            )
-
-    return distancias, coordenadas
-# Función para generar distancias aleatorias entre ciudades y sus coordenadas bidimensionales
-def generar_distanaias_coordenadas(listapuntos):
-    num_ciudades = int(max(listapuntos.shape)/2)
-    distancias = [[0] * (num_ciudades) for _ in range(num_ciudades)]
-    coordenadas = [
-        (listapuntos[i], listapuntos[i+1]) for i in range(0,2*num_ciudades-1,2)
-    ]
-    for i in range(num_ciudades):
-        for j in range(i + 1, num_ciudades):
-            distancias[i][j] = distancias[j][i] = (
-                sum((x - y) ** 2 for x, y in zip(coordenadas[i], coordenadas[j])) ** 0.5
-            )
-    return distancias, coordenadas
+# Función modificada para detectar solo sonrisas
+def buscar_existe(image):
+    existe = "no se detectecta una sonrisa"
+    print("resultado: ", image.shape)
     
-def algoritmo_genetico(num_generaciones,num_ciudades,num_individuos,probabilidad_mutacion,distancias,coordenadas):
-    poblacion = generar_poblacion(num_individuos, num_ciudades)    
-    for generacion in range(num_generaciones):
-        poblacion = sorted(
-            poblacion, key=lambda x: calcular_aptitud(x, distancias, coordenadas)
-        )
-        mejor_individuo = poblacion[0]
-        mejor_distancia = calcular_aptitud(mejor_individuo, distancias, coordenadas)        
-        seleccionados = seleccion_torneo(poblacion, distancias, coordenadas)
-        nueva_poblacion = []
-        for i in range(0, len(seleccionados), 2):
-            padre1, padre2 = seleccionados[i], seleccionados[i + 1]
-            hijo1 = cruzar(padre1, padre2)
-            hijo2 = cruzar(padre2, padre1)
-            hijo1 = mutar(hijo1, probabilidad_mutacion)
-            hijo2 = mutar(hijo2, probabilidad_mutacion)
-            nueva_poblacion.extend([hijo1, hijo2])
-        poblacion = nueva_poblacion        
-    mejor_solucion = poblacion[0]
-    mejor_distancia = calcular_aptitud(mejor_solucion, distancias, coordenadas)
-    return mejor_solucion, mejor_distancia
+    # Cargar el clasificador de sonrisas
+    smile_cascade = cv2.CascadeClassifier('haarcascade_smile.xml')
+    
+    # Convertir la imagen a escala de grises
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    
+    # Detectar sonrisas en la imagen completa
+    smiles = smile_cascade.detectMultiScale(gray, 1.8, 20, minSize=(25, 25))
+
+    numsmile = len(smiles)
+    if len(smiles) > 0:
+        existe = "se ha detectado al menos 1 sonrisa"
+    return existe
 
 # Ruta de predicción
-@app.post("/predict/")
-async def predict(data: InputData):
+@app.post('/predict/')
+async def predict(file: UploadFile = File(...)):
     try:
-        input_data = np.array(data.data).reshape(
-            1, -1
-        )  # Asumiendo que la entrada debe ser de forma (1, num_features)
-        
-        num_ciudades = int(input_data[0][0])
-        num_individuos = int(input_data[0][1])
-        probabilidad_mutacion = float(input_data[0][2])
-        num_generaciones = int(input_data[0][3])
-        distancias, coordenadas = generar_distanaias_coordenadas(np.array(data.data2))
-        print(f"Coordenadas al inicio: {coordenadas}")
-        mejor_solucion, mejor_distancia = algoritmo_genetico(num_generaciones,num_ciudades,num_individuos,probabilidad_mutacion,distancias,coordenadas)
-        mejor_solucion.append(int(mejor_distancia))
+        # Leer la imagen desde el archivo subido
+        image = Image.open(BytesIO(await file.read()))
+        image = np.asarray(image)
         
-        prediction = mejor_solucion
-        print(f"Coordenadas al final: {coordenadas}")
-        print(f"Predicción: {prediction}")
-        #return {"prediction": prediction.tolist()}
+        # Usar la función para detectar sonrisas
+        prediction = buscar_existe(image)
         return {"prediction": prediction}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -1,3 +1,7 @@
 fastapi
 numpy
-pydantic
+pydantic
+opencv-python-headless
+uvicorn[standard]
+python-multipart
+pillow