init app

README.md

@@ -1,10 +1,12 @@
----
-title: PC1 BE
-emoji: 📚
-colorFrom: red
-colorTo: blue
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+title: AG TSP API
+emoji: 🚀
+colorFrom: indigo
+colorTo: blue
+sdk: docker
+app_file: main.py 
+app_port: 8000
+---
+
+### Mi API para la PC1 de CC0A2A
+Endpoint: `/shortest-path/`

main.py

@@ -0,0 +1,256 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+import numpy as np
+import random
+from typing import List, Dict
+
+
+class Point(BaseModel):
+    id: str
+    x: float
+    y: float
+
+
+class PathRequest(BaseModel):
+    points: List[Point]
+
+
+class BezierPoint(BaseModel):
+    x: float
+    y: float
+
+
+class PathResponse(BaseModel):
+    path: List[str]
+    distance: float
+    bezierPoints: List[BezierPoint]
+
+    class Config:
+        allow_population_by_field_name = True
+        alias_generator = lambda field_name: field_name.replace('_', '')
+
+
+class InputData(BaseModel):
+    data: List[float]  # Lista de características numéricas (flotantes)
+
+
+app = FastAPI()
+
+
+def generate_bezier_points(
+        path: List[str],
+        points_dict: Dict[str, Point],
+        segments: int = 50
+        ):
+    bezier_points = []
+    if len(path) < 3:
+        return bezier_points
+
+    for i in range(len(path) - 2):
+        p0 = points_dict[path[i]]
+        p1 = points_dict[path[i+1]]
+        p2 = points_dict[path[i+2]]
+
+        for t in np.linspace(0, 1, segments):
+            # B(t) = (1-t)²P0 + 2(1-t)tP1 + t²P2
+            x = round((1-t)**2 * p0.x + 2*(1-t)*t * p1.x + t**2 * p2.x, 3)
+            y = round((1-t)**2 * p0.y + 2*(1-t)*t * p1.y + t**2 * p2.y, 3)
+            bezier_points.append(BezierPoint(x=x, y=y))
+    return bezier_points
+
+# ------------- 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
+
+
+def calcular_aptitud(individuo, distancias, coordenadas):
+    # Función para evaluar la aptitud de
+    #  un individuo (distancia total del recorrido)
+    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
+
+
+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}")
+    try:
+        # Convertir la lista de entrada a un array de NumPy para la predicción
+        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_distancias(num_ciudades)
+        mejor_solucion, mejor_distancia = algoritmo_genetico(
+            num_generaciones,
+            num_ciudades,
+            num_individuos,
+            probabilidad_mutacion,
+            distancias,
+            coordenadas
+        )
+        # print(type(mejor_solucion),mejor_solucion
+        respuesta = list(mejor_solucion)
+        print(respuesta)
+        prediction = respuesta
+        # return {"prediction": prediction.tolist()}
+        return {"prediction": prediction}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.post("/shortest-path/", response_model=PathResponse)
+async def find_shortest_path(
+    request: PathRequest,
+    population: int = 50,
+    mutation_prob: float = 0.1,
+    generations: int = 100
+):
+    try:
+        points = request.points
+        num_cities = len(points)
+        if num_cities < 3:
+            raise HTTPException(
+                status_code=400,
+                detail="need at least 3 points"
+                )
+
+        print(
+            f"parametros: population={population}, mutation_prob={mutation_prob}, generations={generations}"
+            )
+
+        distancias = [[0] * num_cities for _ in range(num_cities)]
+        coordenadas = [(p.x, p.y) for p in points]
+        points_dict = {p.id: p for p in points}
+        for i in range(num_cities):
+            for j in range(i + 1, num_cities):
+                dist = ((coordenadas[i][0] - coordenadas[j][0])**2 +
+                        (coordenadas[i][1] - coordenadas[j][1])**2)**0.5
+                distancias[i][j] = distancias[j][i] = dist
+        mejor_solucion, mejor_distancia = algoritmo_genetico(
+            num_generaciones=generations,
+            num_ciudades=num_cities,
+            num_individuos=population,
+            probabilidad_mutacion=mutation_prob,
+            distancias=distancias,
+            coordenadas=coordenadas
+        )
+        path_ids = [points[i].id for i in mejor_solucion]
+        bezier_points = generate_bezier_points(path_ids, points_dict)
+        return PathResponse(
+            path=path_ids,
+            distance=mejor_distancia,
+            bezierPoints=bezier_points
+        )
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=str(e)
+            )

requirements.txt

@@ -0,0 +1,37 @@
+annotated-types==0.7.0
+anyio==4.9.0
+backend-ag @ file:///C:/Users/la/repos/github.com/axvg/uni/2025-01/CC0A2A/semanas/04/pc1/backend
+certifi==2025.1.31
+click==8.1.8
+colorama==0.4.6
+dnspython==2.7.0
+email_validator==2.2.0
+fastapi==0.115.12
+fastapi-cli==0.0.7
+h11==0.14.0
+httpcore==1.0.8
+httptools==0.6.4
+httpx==0.28.1
+idna==3.10
+Jinja2==3.1.6
+markdown-it-py==3.0.0
+MarkupSafe==3.0.2
+mdurl==0.1.2
+numpy==2.2.5
+pydantic==2.11.3
+pydantic_core==2.33.1
+Pygments==2.19.1
+python-dotenv==1.1.0
+python-multipart==0.0.20
+PyYAML==6.0.2
+rich==14.0.0
+rich-toolkit==0.14.1
+shellingham==1.5.4
+sniffio==1.3.1
+starlette==0.46.2
+typer==0.15.2
+typing-inspection==0.4.0
+typing_extensions==4.13.2
+uvicorn==0.34.2
+watchfiles==1.0.5
+websockets==15.0.1