Update app.py

app.py

@@ -1,92 +1,91 @@
-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
-from typing import List
-
-class InputData(BaseModel):
-  data: str  # image url
-
-app = FastAPI()
-
-# Función para construir el modelo manualmente
-def build_model():
-  with open('somcancer.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)
-
-# 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))
+import pickle
+from minisom import MiniSom
+import numpy as np
+import json
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import List
+import math
+
+class InputData(BaseModel):
+    data: List[float]  # Lista de características numéricas (floats)
+
+app = FastAPI()
+
+# Função para construir o modelo manualmente
+def build_model():
+    with open('somcancer.pkl', 'rb') as fid:
+        somhuella = pickle.load(fid)
+    MM = np.loadtxt('matrizMM.txt', delimiter=" ")
+    return somhuella,MM
+    #with open('label_map.json', 'r') as json_file:
+    #    loaded_label_map_str_keys = json.load(json_file)
+
+    # Convertendo as chaves de volta para tuplas
+    #loaded_label_map = {eval(k): v for k, v in loaded_label_map_str_keys.items()}
+    
+    #return somecoli, loaded_label_map
+
+def sobel(I):
+    m, n = I.shape
+    Gx = np.zeros([m-2, n-2], np.float32)
+    Gy = np.zeros([m-2, n-2], np.float32)
+    gx = [[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]]
+    gy = [[1, 2, 1], [0, 0, 0], [-1, -2, -1]]
+    for j in range(1, m-2):
+        for i in range(1, n-2):
+            Gx[j-1, i-1] = sum(sum(I[j-1:j+2, i-1:i+2] * gx))
+            Gy[j-1, i-1] = sum(sum(I[j-1:j+2, i-1:i+2] * gy))
+    return Gx, Gy
+
+def medfilt2(G, d=3):
+    m, n = G.shape
+    temp = np.zeros([m+2*(d//2), n+2*(d//2)], np.float32)
+    salida = np.zeros([m, n], np.float32)
+    temp[1:m+1, 1:n+1] = G
+    for i in range(1, m):
+        for j in range(1, n):
+            A = np.asarray(temp[i-1:i+2, j-1:j+2]).reshape(-1)
+            salida[i-1, j-1] = np.sort(A)[d+1]
+    return salida
+
+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], np.float32)
+    for i in range(m//w):
+        for j in range(n//w):
+            YY = sum(sum(2*Gx[i*w:(i+1)*w, j:j+1] * Gy[i*w:(i+1)*w, j:j+1]))
+            XX = sum(sum(Gx[i*w:(i+1)*w, j:j+1]**2 - Gy[i*w:(i+1)*w, j:j+1]**2))
+            mOrientaciones[i, j] = (0.5 * math.atan2(YY, XX) + math.pi / 2.0) * (180.0 / math.pi)
+    return mOrientaciones
+
+def representativo(imarray):
+    imarray = np.squeeze(imarray)  # Remover a dimensão extra do canal
+    m, n = imarray.shape
+    patron = imarray[1:m-1, 1:n-1]  # de 256x256 a 254x254
+    EE = orientacion(patron, 14)  # retorna EE de 18x18
+    return np.asarray(EE).reshape(-1)
+
+som, MM = build_model()  # Construir o modelo ao iniciar a aplicação
+
+# Rota de previsão
+@app.post("/predict/")
+async def predict(data: InputData):
+    print(f"Data: {data}")
+    global som
+    global MM
+    try:
+        # Converter a lista de entrada para um array de NumPy para a previsão
+        input_data = np.array(data.data).reshape(256, 256, 1)  # Assumindo que a entrada é uma imagem de 256x256 com 1 canal
+        representative_data = representativo(input_data)
+        representative_data = representative_data.reshape(1, -1)  # Reformatar para (1, num_features)
+        
+        w = som.winner(representative_data)
+        prediction = MM[w]
+        
+        return {"prediction": prediction}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))