Upload 3 files

Dockerfile

@@ -1,17 +1,16 @@
 # Usa una imagen base de Python
-FROM python:3.11
+FROM python:3.12.4
 # Establece el directorio de trabajo
 WORKDIR /code
 
-RUN apt-get update && apt-get install ffmpeg libsm6 libxext6  -y
 # Copia los archivos necesarios al contenedor
 COPY ./requirements.txt /code/requirements.txt
-RUN pip install --upgrade pip
 RUN pip install --no-cache-dir -r /code/requirements.txt
-RUN apt-get update && apt-get install -y python3-opencv
 RUN pip install fastapi uvicorn
 
+COPY . .
+
 RUN chmod -R 777 /code
 
 # Comando para ejecutar la aplicación
-CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -1,89 +1,142 @@
-import pickle
-from minisom import MiniSom
-import numpy as np
-import cv2
-
-import urllib.request
-import uuid
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
+import numpy as np
+import random
 from typing import List
 
 class InputData(BaseModel):
-  data: str  # image url
-
+    data: List[float]  # Lista de características numéricas (flotantes)
+    data2: List[float]  # Lista de características numéricas (flotantes)
+    
 app = FastAPI()
 
-# Función para construir el modelo manualmente
-def build_model():
-  with open('somlucuma.pkl', 'rb') as fid:
-    somecoli = pickle.load(fid)
-  MM = np.loadtxt('matrizMM.txt', delimiter=" ")
-  return somecoli,MM
-
-som,MM = build_model()  # Construir el modelo al iniciar la aplicación
-
-from scipy.ndimage import median_filter
-from scipy.signal import convolve2d
-
-def sobel(patron):
-  gx = np.array([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]], dtype=np.float32)
-  gy = np.array([[1, 2, 1], [0, 0, 0], [-1, -2, -1]], dtype=np.float32)
-
-  Gx = convolve2d(patron, gx, mode='valid')
-  Gy = convolve2d(patron, gy, mode='valid')
-
-  return Gx, Gy
-
-def medfilt2(G, d=3):
-  return median_filter(G, size=d)
-
-def orientacion(patron, w):
-  Gx, Gy = sobel(patron)
-  Gx = medfilt2(Gx)
-  Gy = medfilt2(Gy)
-
-  m, n = Gx.shape
-  mOrientaciones = np.zeros((m // w, n // w), dtype=np.float32)
-
-  for i in range(m // w):
-    for j in range(n // w):
-      Gx_patch = Gx[i*w:(i+1)*w, j*w:(j+1)*w]
-      Gy_patch = Gy[i*w:(i+1)*w, j*w:(j+1)*w]
-
-      YY = np.sum(2 * Gx_patch * Gy_patch)
-      XX = np.sum(Gx_patch**2 - Gy_patch**2)
-
-      mOrientaciones[i, j] = (0.5 * np.arctan2(YY, XX) + np.pi / 2.0) * (18.0 / np.pi)
-
-  return mOrientaciones
-
-def redimensionar(img, h, v):
-  return cv2.resize(img, (h, v), interpolation=cv2.INTER_AREA)
-
-def prediction(som, imgurl):
-  archivo = f"/tmp/test-{uuid.uuid4()}.jpg"
-  urllib.request.urlretrieve(imgurl, archivo)
-  Xtest = redimensionar(cv2.imread(archivo),256,256)
-  Xtest = np.array(Xtest)
-  Xtest = cv2.cvtColor(Xtest, cv2.COLOR_BGR2GRAY)
-
-  orientaciones = orientacion(Xtest, w=14)
-  Xtest = Xtest.astype('float32') / 255.0
-  orientaciones = orientaciones.reshape(-1)
-  return som.winner(orientaciones)
+# ------------- 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
+    
+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
 
 # Ruta de predicción
 @app.post("/predict/")
 async def predict(data: InputData):
-  print(f"Data: {data}")
-  global som
-  global MM
-  try:
-    # Convertir la lista de entrada a un array de NumPy para la predicción
-    imgurl = data.data
-    print(type(data.data))
-    w = prediction(som, imgurl)
-    return {"prediction": MM[w]}
-  except Exception as e:
-    raise HTTPException(status_code=500, detail=str(e))
+    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))
+        
+        prediction = mejor_solucion
+        print(f"Coordenadas al final: {coordenadas}")
+        print(f"Predicción: {prediction}")
+        #return {"prediction": prediction.tolist()}
+        return {"prediction": prediction}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))

requirements.txt

@@ -1,9 +1,3 @@
-scikit-learn
-#pillow
-#tensorflow
-minisom
 fastapi
 numpy
-pydantic
-opencv-python
-matplotlib
+pydantic