update again with requiriments.txt

Dockerfile

@@ -1,24 +1,6 @@
 # Use Python 3.13 slim image as base
 FROM python:3.10
 
-# Set working directory
-WORKDIR /app
-
-# Install pip and build tools
-RUN apt-get update && apt-get install -y --no-install-recommends \
-    build-essential \
-    && rm -rf /var/lib/apt/lists/*
-
-# install uv
-COPY --from=ghcr.io/astral-sh/uv:latest /uv /uvx /bin/
-
-# Copy the application into the container
-COPY pyproject.toml uv.lock ./
-COPY src/ ./src/
-
-# Install the application dependencies
-RUN uv sync --frozen --no-cache
-
 # Set up a new user named 'user'
 RUN useradd user
 
@@ -31,9 +13,12 @@ ENV HOME=/home/user \
 # Set the working directory to the user's home directory
 WORKDIR $HOME/app
 
-# Copy the current directory contents into the container at $HOME/app setting the owner
-COPY --chown=user . $HOME/app
+COPY --chown=user ./ $HOME/app
 
+RUN pip install -r requirements.txt
 
 # Set the default command to run the FastAPI app with Uvicorn
-CMD ["/home/user/app/.venv/bin/uvicorn", "src.kimi_service.app:app", "--host", "0.0.0", "--port", "7860"]
+CMD ["uvicorn", "src.kimi_service.app:app", "--host", "0.0.0.0", "--port", "7860"]
+
+
+

README.md

@@ -1,11 +1,236 @@
----
-title: Bogota Land Space
-emoji: 📚
-colorFrom: blue
-colorTo: blue
-sdk: docker
-pinned: false
-license: mit
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+<h1>Clasificación del Uso Predial Usando Imágenes de GSV y  Modelos de Lenguaje Visual</h1>
+
+<p align="center">
+ <img src="https://img.shields.io/github/issues/chansoopark98/Tensorflow-Keras-Realtime-Segmentation">
+ <img src="https://img.shields.io/github/forks/chansoopark98/Tensorflow-Keras-Realtime-Segmentation">
+ <img src="https://img.shields.io/github/stars/chansoopark98/Tensorflow-Keras-Realtime-Segmentation">
+ <img src="https://img.shields.io/github/license/chansoopark98/Tensorflow-Keras-Realtime-Segmentation">
+ </p>
+
+<br>
+
+<p align="justify">
+ <img alt="Python" src ="https://img.shields.io/badge/Python-3.13-3776AB.svg?&style=for-the-badge&logo=Python&logoColor=white"/>
+ <img src ="https://img.shields.io/badge/Docker-0db7ed.svg?&style=for-the-badge&logo=Docker&logoColor=white"/>
+ <img src ="https://img.shields.io/badge/HUggingface-EB8F00.svg?&style=for-the-badge&logo=Huggingface&logoColor=white"/>
+ <img src ="https://img.shields.io/badge/JUpyter-5C3EE8.svg?&style=for-the-badge&logo=JUpyter&logoColor=white"/>
+ <img src ="https://img.shields.io/badge/Numpy-013243.svg?&style=for-the-badge&logo=Numpy&logoColor=white"/>
+ <br>
+ <br>
+</p>
+
+<p align="justify">
+Este repositorio contiene un modelo de lenguaje visual que automatiza la clasificación del uso del suelo en Bogotá utilizando imágenes de Google Street View. El modelo utiliza una arquitectura de lenguaje visual avanzada (Kimi-VL) que no solo clasifica las imágenes en diferentes categorías de uso del suelo, sino que también proporciona un razonamiento detallado sobre su decisión.
+</p>
+
+# Contenido
+
+1. Requerimientos
+2. Instalacion
+3. Uso
+   - 3.1. Entrenamiento del Modelo
+   - 3.2. Despliegue del Modelo
+5. Dataset
+6. Arquitectura del Modelo
+7. Azure ML Deployment
+8. Uso del API
+   
+## Estructura del Proyecto
+
+```
+├── data/                      # solo visible en local por razones legales
+│   └── minisample_v1/         
+│       ├── bodegas/           
+│       ├── comerciales1-5/    
+│       ├── dotacionales1/     
+│       ├── mixto1-3/         
+│       ├── otros/            
+│       └── residenciales/    
+├── src/
+│   ├── data/                # Utilidades para carga de datos
+│   ├── model/               # Código para entrenamiento del modelo
+│   ├── deploy_to_azure.py   # Script de despliegue en Azure ML
+│   └── score.py             # Script de inferencia del modelo
+├── pyproject.toml           # Dependencias del proyecto
+└── README.md                # Este archivo
+
+```
+
+## 1. Requirements
+
+- Python >= 3.13
+- Dependencias especificadas en pyproject.toml:
+  - PyTorch
+  - Transformers
+  - Azure ML SDK
+  - Otras librerías para procesamiento de datos
+
+## 2. Instalación
+
+1. Clona el repositorio:
+```bash
+git clone <repository-url>
+cd bogota-land-use
+```
+
+2. Instala las dependencias usando uv:
+```bash
+uv venv
+source .venv/bin/activate
+uv pip install -e .
+```
+
+## 3. Uso
+
+### 3.1 Evaluación del Modelo
+
+Para evaluar imágenes usando el modelo:
+
+```bash
+python src/model/train.py --image_paths path/to/image1.jpg path/to/image2.jpg
+```
+
+El script realizará lo siguiente:
+1. Cargar las imágenes especificadas
+2. Utilizar el modelo Kimi-VL para analizar cada imagen
+3. Proporcionar una clasificación detallada que incluye:
+   - Categoría asignada
+   - Nivel de confianza (Alto/Medio/Bajo)
+   - Razonamiento paso a paso
+   - Categorías alternativas relevantes
+4. Guardar los resultados en formato JSON
+
+### 3.2 Despliegue del Modelo
+
+Para desplegar el modelo entrenado en Azure ML:
+
+1. Configura las credenciales de Azure:
+
+```bash
+export AZURE_SUBSCRIPTION_ID="your-subscription-id"
+export AZURE_RESOURCE_GROUP="your-resource-group"
+export AZURE_ML_WORKSPACE="your-workspace-name"
+```
+
+2. Despliega el modelo:
+```bash
+python src/deploy_to_azure.py
+```
+
+## 4. Dataset y Categorías
+
+El modelo clasifica las imágenes en 20 categorías detalladas:
+
+1. **RESIDENCIALES**: Viviendas, casas, edificios PH's y condominios
+2. **COMERCIALES 1**: Locales comerciales y establecimientos de compra-venta
+3. **COMERCIALES 2**: Oficinas y servicios empresariales
+4. **COMERCIALES 3**: Actividades artesanales y transformación local
+5. **COMERCIALES 4**: Hoteles, moteles y restaurantes
+6. **COMERCIALES 5**: Oficinas operativas y depósitos
+7. **CENTROS COMERCIALES**: Complejos comerciales y malls
+8. **BODEGAS**: Instalaciones de almacenamiento y uso industrial
+9. **PARQUEADEROS**: Estacionamientos
+10. **DOTACIONALES 1**: Servicios comunitarios
+11. **DOTACIONALES 2**: Instituciones educativas
+12. **DOTACIONALES 3**: Centros de salud y hospitales
+13. **DOTACIONALES 4**: Edificios religiosos
+14. **DOTACIONALES 5**: Instalaciones recreativas y culturales
+15. **ESPECIALES**: Áreas militares, cementerios, aeropuertos
+16. **MOLES**: Grandes edificaciones en construcción
+17. **RURALES**: Estructuras rurales y agrícolas
+18. **MIXTO 1**: Residencial con comercial tipo 1
+19. **MIXTO 2**: Residencial con oficinas
+20. **MIXTO 3**: Comercial con oficinas
+
+Cada categoría está claramente definida con criterios específicos que el modelo utiliza para su análisis y clasificación.
+
+## 5. Arquitectura del Modelo
+
+El proyecto utiliza el modelo Kimi-VL (Visual Language) de Moonshot AI, una arquitectura avanzada de lenguaje visual que combina:
+- Procesamiento de imágenes de alta calidad
+- Comprensión del contexto visual detallada
+- Capacidad de razonamiento paso a paso
+- Generación de explicaciones en lenguaje natural
+
+El modelo:
+- Recibe imágenes a nivel de calle como entrada
+- Analiza las características arquitectónicas y contextuales
+- Proporciona una clasificación basada en razonamiento
+- Incluye niveles de confianza y categorías alternativas
+- Genera explicaciones detalladas de su decisión
+
+## 6. Azure ML Deployment
+
+El modelo se despliega como un endpoint online gestionado en Azure ML. El proceso de despliegue:
+
+1. **Registro del Modelo**:
+   - El modelo Kimi-VL se registra en Azure ML workspace
+   - Se incluyen todos los archivos necesarios para inferencia
+
+2. **Configuración del Endpoint**:
+   - Se crea un endpoint online con autenticación por clave
+   - Se configura el ambiente de ejecución con las dependencias necesarias
+
+3. **Despliegue del Modelo**:
+   - Se utiliza una instancia Standard_DS3_v2 para el servicio
+   - El modelo procesa las imágenes en lotes para mayor eficiencia
+   - Incluye manejo automático de errores y logging
+
+4. **Características del Servicio**:
+   - API REST para inferencia en tiempo real
+   - Procesamiento de imágenes en múltiples formatos
+   - Respuestas detalladas con razonamiento
+   - Escalado automático según la demanda
+
+## 7. Uso del API
+
+Una vez desplegado, puedes enviar peticiones HTTP POST al endpoint con imágenes:
+
+```python
+import requests
+import base64
+import json
+
+def encode_image(image_path):
+    with open(image_path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+# Prepare the request
+image_data = encode_image("path/to/image.jpg")
+data = {"image": image_data}
+
+# Send request to endpoint
+response = requests.post(
+    "YOUR_ENDPOINT_URL",
+    json=data,
+    headers={"Authorization": f"Bearer {api_key}"}
+)
+
+# Get prediction
+result = response.json()
+print(f"Categoría predicha: {result['classification']}")
+print(f"Nivel de confianza: {result['confidence']}")
+print("\nRazonamiento:")
+for step, explanation in result['reasoning'].items():
+    print(f"{step}: {explanation}")
+
+# Si hay categorías alternativas
+if 'alternative_categories' in result:
+    print("\nCategorías alternativas relevantes:")
+    for category in result['alternative_categories']:
+        print(f"- {category}")
+```
+
+La respuesta incluye:
+- La categoría asignada
+- Nivel de confianza (Alto/Medio/Bajo)
+- Razonamiento paso a paso
+- Categorías alternativas relevantes
+
+## Licencia
+
+[Agrega aquí la información de tu licencia]
+
+## Contribuidores
+
+[Agrega aquí información sobre los contribuidores]

app.py

@@ -0,0 +1,80 @@
+import io
+from PIL import Image
+import base64
+
+from fastapi import FastAPI, APIRouter, HTTPException
+from inference import Inference
+import uvicorn
+import logging
+from typing import Optional
+
+from types_io import ClassificationRequest, ImageData
+
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+log = logging.getLogger(__name__)
+
+
+def decode_base64_image(base64_str: str) -> Optional[Image.Image]:
+    """
+    Decode a base64 encoded string into a PIL Image object.
+
+    Args:
+        base64_str (str): Base64 encoded image string
+
+    Returns:
+        Optional[Image.Image]: PIL Image object if successful, None if decoding fails
+
+    Raises:
+        Exception: Logged and caught internally, returns None on any error
+    """
+    try:
+        image_data = base64.b64decode(base64_str)
+        image = Image.open(io.BytesIO(image_data))
+        return image
+    except Exception as e:
+        log.error(f"Error processing image: {str(e)}")
+        return None
+
+
+app = FastAPI(title="Kimi Service", version="1.5.0")
+inference = Inference()
+router = APIRouter()
+
+
+@app.get("/")
+async def home():
+    return {"message": "Welcome to Kimi Service!"}
+
+
+@router.post("/classify", response_model=ImageData)
+async def classify(request: ClassificationRequest):
+    try:
+        log.info(f"Processing {len(request.images)} images")
+        # Decode images from base64 or load from file paths
+        images = []
+        for img_str in request.images:
+            img = decode_base64_image(img_str)
+            images.append(img)
+        log.info(f"Decoded {len(images)} images successfully")
+
+        res = inference.classify_building(images)
+        if res is None:
+            raise HTTPException(status_code=500, detail="Classification failed")
+        return res
+
+    except ValueError as ve:
+        log.error(f"Validation error: {str(ve)}")
+        raise HTTPException(status_code=400, detail=str(ve))
+    except Exception as e:
+        log.error(f"Error during classification: {str(e)}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+app.include_router(router)
+
+if __name__ == "__main__":
+    uvicorn.run("app:app", reload=True, port=7860, host="0.0.0.0")

classifier.py

@@ -0,0 +1,174 @@
+from typing import List
+import logging
+import outlines
+from model import Model
+from PIL import Image
+from types_io import ImageData
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+logger = logging.getLogger(__name__)
+
+
+LAND_USE_PROMPT = f"""
+Task: You are a structured image analysis agent. Given an image of a building front, generate a comprehensive tag list and provide the thinking process for an image classification systems.
+
+Requirement: The output should generate a minimum of 3 categories for each input.
+
+Confidence: Confidence score for each category, ranging from 0 (very confident) to 1 (little/none confident).
+
+Categories :
+
+- Residenciales: Buildings intended for housing - Houses, PH Buildings, Condominiums.
+- Comerciales1: Refers to the storage, distribution, or exchange of products, goods, or services with a commercial interest.
+- Comerciales2: Buildings where activities aimed at providing services are carried out.
+- Comerciales3: Buildings used for artisanal activities where raw materials are transformed on a local scale.
+- Comerciales4: Hotels, Motels, and Restaurants.
+- Comerciales5: Operational offices and warehouses.
+- Centros_Comerciales: Commercial premises located on properties of one or several buildings.
+- Bodegas: Buildings in warehouse-type constructions dedicated to commercial, industrial, or storage activities.
+- Parqueaderos: Buildings designed for vehicle parking.
+- Dotacionales1: Buildings where activities aimed at the welfare or service of a community are carried out.
+- Dotacionales2: Buildings designed to carry out educational or training activities.
+- Dotacionales3: Buildings with the necessary infrastructure to provide surgical and/or hospitalization services.
+- Dotacionales4: Buildings for religious worship owned by communities or religious congregations.
+- Dotacionales5: Theaters, cinemas, swimming pools, museums, sports, events, or shows.
+- Especiales: Military administrative areas, cemeteries, airport runways.
+- Moles: Large buildings in height (>4 floors) or area (>10,000 m²), usually under construction.
+- Rurales: Sheds, kiosks, shelters, barns, stables, silos, etc. 
+- Mixto1: (Residencial + Comercial1) Housing and commercial premises.
+- Mixto2: (Residencial + Comercial2) Housing and offices.
+- Mixto3: (Comercial1 + Comercial2) Commercial premises and offices.
+
+
+Return the information in the following JSON schema:
+{ImageData.model_json_schema()}
+"""
+
+
+class Classifier:
+    def __init__(self, MAX_NEW_TOKENS: int = 1024):
+        self.max_new_tokens = MAX_NEW_TOKENS
+
+        logger.info("Initializing Classifier")
+        logger.info("Loading model...")
+        self.model = Model.load_model()
+        logger.info("Loading processor...")
+        self.processor = Model.load_processor()
+        logger.info("Classifier initialization complete")
+        logger.info("Setting up image data generator...")
+        self.image_data_generator = outlines.Generator(self.model, ImageData)
+
+
+    def get_response(self, images: List[Image.Image]) -> dict:
+        logger.info(f"Processing classification request for {len(images)} images")
+        logger.info("Loading and preprocessing images...")
+        images = self.get_input_tensor(images)
+        logger.debug("Successfully preprocessed images")
+
+        logger.info("Preparing input messages...")
+        messages = self.prepare_messages(images, LAND_USE_PROMPT)
+
+        response = self.generate_model_response(images, messages)
+
+        return {"output": response}
+
+    def get_input_tensor(self, images: List[Image.Image]) -> List[Image.Image]:
+        """
+        Preprocess a list of PIL images.
+        Args:
+            images (List[Image.Image]): List of PIL images to be processed.
+        Returns:
+            List[Image.Image]: List of preprocessed images ready for classification.
+        """
+        if not images:
+            raise ValueError("No images provided for classification.")
+
+        logger.info(f"Preprocessing {len(images)} images...")
+        processed_images = []
+        for idx, img in enumerate(images):
+            logger.debug(f"Processing image at index: {idx}")
+            try:
+                img = self.resize_image(img)
+                processed_images.append(img)
+                logger.debug(f"Successfully processed image at index: {idx}")
+            except Exception as e:
+                logger.error(f"Error processing image at index {idx}: {str(e)}")
+                raise
+        return processed_images
+
+    def generate_model_response(self, images: List[Image.Image], messages: List[dict]) -> str:
+        """
+        Generate response from the model.
+        Args:
+            images (List[Image.Image]): List of preprocessed images.
+            messages (List[dict]): Messages for the processor.
+        Returns:
+            str: Decoded response from the model.
+        """
+        logger.info("Applying chat template...")
+        text = self.processor.apply_chat_template(
+            messages, add_generation_prompt=True, return_tensors="pt"
+        )
+        logger.info("Generating response with outlines...")
+        result = self.image_data_generator(
+            {
+                "text": text,
+                "images": images
+            },
+            max_new_tokens=self.max_new_tokens
+        )
+        logger.debug("Successfully generated response")
+
+        return result
+
+    @staticmethod
+    def resize_image(image: Image.Image, max_size: int = 224) -> Image.Image:
+        """
+        Resize an image while maintaining aspect ratio.
+
+        Args:
+            image: PIL Image object to resize
+            max_size: Maximum dimension (width or height) of the output image
+
+        Returns:
+            PIL Image: Resized image with maintained aspect ratio
+        """
+        # Get current dimensions
+        width, height = image.size
+
+        # Calculate scaling factor to fit within max_size
+        scale = min(max_size / width, max_size / height)
+
+        # Only resize if image is larger than max_size
+        if scale < 1:
+            new_width = int(width * scale)
+            new_height = int(height * scale)
+            image = image.resize(
+                (new_width, new_height),
+                Image.Resampling.LANCZOS
+            )
+
+        return image
+
+    @staticmethod
+    def prepare_messages(images: List[Image.Image]) -> List[dict]:
+        """
+        Prepare messages for the processor.
+        Args:
+            images (List[Image.Image]): List of PIL images.
+            classification_prompt (str): The prompt for classification.
+        Returns:
+            List[dict]: Messages for the processor.
+        """
+        return [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "image", "image": image} for image in images
+                ] + [{"type": "text", "text": LAND_USE_PROMPT}],
+            },
+        ]

inference.py

@@ -0,0 +1,50 @@
+from classifier import Classifier
+from typing import List
+from PIL import Image
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+logger = logging.getLogger(__name__)
+
+classifier = Classifier()
+
+
+class Inference():
+    def __init__(self):
+        self.classifier = classifier
+
+    def _prepare_images(self, images: List[Image.Image]) -> List[Image.Image]:
+        """
+        Prepare PIL images for classification by converting to RGB
+        Args:
+            images: List of PIL Image objects
+        Returns:
+            List of RGB PIL Image objects
+        """
+        prepared_images = []
+        for idx, image in enumerate(images):
+            try:
+                # Convert to RGB to ensure compatibility
+                image = image.convert('RGB')
+                prepared_images.append(image)
+            except Exception as e:
+                raise ValueError(f"Error processing image {idx}: {str(e)}")
+
+        return prepared_images
+
+    def classify_building(self, images: List[Image.Image]) -> dict:
+        """
+        Classify building type from a list of PIL Image objects
+        Args:
+            images: List of PIL Image objects
+        Returns:
+            Classification response
+        """
+        logger.info(f"Preparing {len(images)} images for classification")
+        prepared_images = self._prepare_images(images)
+        logger.info(f"Image preparation successful")
+        response = self.classifier.get_response(prepared_images)
+        return response

model.py

@@ -0,0 +1,63 @@
+import torch
+from transformers import AutoModelForCausalLM, AutoProcessor
+import outlines
+import logging
+
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+)
+logger = logging.getLogger(__name__)
+
+
+class Model:
+    """
+    Handles loading and managing the Kimi-VL-A3B-Thinking model and processor.
+    Loads model and processor once and provides accessors.
+    """
+
+    # ALL MODEL CONFIGURATIONS
+    _model = None
+    _processor = None
+    MODEL_PATH = "moonshotai/Kimi-VL-A3B-Thinking-2506"
+    model_class = AutoModelForCausalLM
+    processor_class = AutoProcessor
+
+    model_kwargs = {
+        "device_map": "auto",
+        "torch_dtype": "auto",
+        "trust_remote_code": True
+    }
+    processor_kwargs = {
+        "device_map": "auto",
+        "trust_remote_code": True
+    }
+
+    @classmethod
+    def load(cls):
+        if cls._model is None:
+            try:
+                tf_model = cls.model_class.from_pretrained(
+                    cls.MODEL_PATH, **cls.model_kwargs
+                )
+                tf_processor = cls.processor_class.from_pretrained(
+                    cls.MODEL_PATH, **cls.processor_kwargs
+                )
+            except Exception as e:
+                logger.error(f"Failed to load model or processor: {str(e)}")
+                raise
+
+            cls._model = outlines.from_transformers(tf_model, tf_processor)
+            cls._processor = tf_processor
+
+        return cls._model, cls._processor
+
+    @classmethod
+    def load_model(cls):
+        model, _ = cls.load()
+        return model
+
+    @classmethod
+    def load_processor(cls):
+        _, processor = cls.load()
+        return processor

requirements.txt

@@ -1,14 +1,14 @@
-fastapi>=0.115.12
-requests
-uvicorn>=0.34.3
-sentencepiece
-torch>=2.7.0
-torchvision>=0.22.0
 datasets>=3.6.0
 pillow>=11.2.1
+scikit-learn>=1.6.1
+torch>=2.7.0
+torchaudio>=2.7.0
+torchvision>=0.22.0
 transformers>=4.52.3
 accelerate>=1.7.0
 tiktoken>=0.9.0
 blobfile>=3.0.0
-pip>=25.1.1
-outlines>=1.0.2
+fastapi>=0.115.12
+uvicorn[standard]>=0.34.3
+outlines>=1.0.2
+requests>=2.32.3

types_io.py

@@ -0,0 +1,96 @@
+
+from enum import Enum
+from pydantic import BaseModel, Field, confloat
+from pydantic.types import StringConstraints
+from typing import List
+from typing_extensions import Annotated
+
+
+class ClassificationRequest(BaseModel):
+    """
+    Request model for image classification.
+    Contains a list of base64-encoded images or file paths.
+    """
+    images: List[str] = Field(
+        ...,
+        example=[
+            "<base64-image-1>",
+            "<base64-image-2>"
+        ]
+    )
+
+
+class TagType(Enum):
+    """
+    Enum for all possible building tag categories.
+    """
+    RESIDENCIALES = "Residenciales"
+    COMERCIALES1 = "Comerciales1"
+    COMERCIALES2 = "Comerciales2"
+    COMERCIALES3 = "Comerciales3"
+    COMERCIALES4 = "Comerciales4"
+    COMERCIALES5 = "Comerciales5"
+    CENTROS_COMERCIALES = "Centros_Comerciales"
+    BODEGAS = "Bodegas"
+    PARQUEADEROS = "Parqueaderos"
+    DOTACIONALES1 = "Dotacionales1"
+    DOTACIONALES2 = "Dotacionales2"
+    DOTACIONALES3 = "Dotacionales3"
+    DOTACIONALES4 = "Dotacionales4"
+    DOTACIONALES5 = "Dotacionales5"
+    ESPECIALES = "Especiales"
+    MOLES = "Moles"
+    RURALES = "Rurales"
+    MIXTO1 = "Mixto1"
+    MIXTO2 = "Mixto2"
+    MIXTO3 = "Mixto3"
+
+
+class ImageTag(BaseModel):
+    """
+    Represents a single classification tag and its confidence score.
+    """
+    category: TagType = Field(
+        ...,
+        example=TagType.RESIDENCIALES
+    )
+    confidence: Annotated[
+        confloat(ge=0.0, le=1.0),
+        Field(
+            description=(
+                "Confidence score for the tag, between 0 (not confident) "
+                "and 1 (very confident)."
+            ),
+            example=0.92
+        )
+    ]
+
+
+class ImageData(BaseModel):
+    """
+    Response model for image classification results.
+    Contains a list of classification tags and a summary string.
+    """
+    classification: List[ImageTag] = Field(
+        ...,
+        min_items=3,
+        max_items=5,
+        description="List of classification tags for the image.",
+        example=[
+            {"category": "Residenciales", "confidence": 0.92},
+            {"category": "Comerciales1", "confidence": 0.65},
+            {"category": "Moles", "confidence": 0.33}
+        ]
+    )
+    think: Annotated[
+        str,
+        StringConstraints(min_length=100, max_length=2048),
+        Field(
+            description="A summary of the </think> section of the output.",
+            example=(
+                "This building is primarily residential with some commercial "
+                "activity on the ground floor. The structure and facade "
+                "suggest a mixed-use property typical of urban environments."
+            )
+        )
+    ]