Initial commit: Setup FastAPI application for HF Spaces

.gitignore

@@ -0,0 +1,63 @@
+# Python-related files
+__pycache__/
+*.py[cod]
+*.swp
+.DS_Store
+*.egg-info/
+
+# Virtual environment
+venv/
+env/
+*.venv/
+
+# Jupyter Notebooks checkpoints
+.ipynb_checkpoints/
+
+# Logs
+logs/
+*.log
+
+# Hugging Face Transformers cache
+~/.cache/huggingface/
+
+# Docker-related files
+*.dockerignore
+
+# Ignore compiled code
+*.so
+*.o
+*.out
+*.a
+
+# Ignore OS-specific files
+Thumbs.db
+ehthumbs.db
+
+# Ignore FastAPI auto-generated files
+*.db
+instance/
+.env
+.env.local
+.env.*.local
+
+# VS Code settings
+.vscode/
+.history/
+
+# Ignore dependency files
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Ignore coverage files
+.coverage
+htmlcov/
+coverage.xml
+
+# Ignore test-related files
+.tox/
+.pytest_cache/
+nosetests.xml
+test-reports/
+
+# Ignore Hugging Face Spaces cache
+space_runtime/

Dockerfile

@@ -0,0 +1,16 @@
+FROM python:3.9
+
+WORKDIR /app
+
+ENV HF_HOME=/app/hf_cache
+ENV HF_TOKEN=${HF_TOKEN}
+RUN mkdir -p /app/hf_cache && chmod 777 /app/hf_cache
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860", "--workers", "1"]

README.md

@@ -0,0 +1,46 @@
+---
+title: fclip_back2
+emoji: 🌖
+colorFrom: purple
+colorTo: yellow
+sdk: docker
+pinned: false
+license: cc-by-nc-4.0
+short_description: Generate text and image embeddings for clothing items
+---
+
+# Install
+
+### Create SSH key
+
+```
+ls ~/.ssh/id_rsa.pub
+ssh-keygen -t rsa -b 4096 -C "your-email@example.com"
+cat ~/.ssh/id_rsa.pub
+```
+
+### Add key to HF SSH key settings
+
+### Clone project
+
+```
+git clone https://huggingface.co/spaces/precove/fclip_back2
+python -m venv venv
+source venv/bin/activate
+pip install -r requirements.txt
+```
+
+# Usage
+
+### FastAPI
+
+```
+uvicorn app:app --host 0.0.0.0 --port 8080 --reload
+```
+
+### Docker
+
+```
+docker build -t fclip . 
+docker run -p 8080:7860 fclip
+```

app.py

@@ -0,0 +1,52 @@
+import gc
+from fastapi import FastAPI, Depends
+
+from src.encoder import FashionCLIPEncoder
+from src.models import TextRequest, ImageRequest, Response
+from src.auth import verify_token
+from src.utils import delete_images
+
+
+encoder = FashionCLIPEncoder(normalize=True)
+app = FastAPI()
+app.state.req_count = 0
+COLLECT_GC_EVERY = 20
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "ok",
+    }
+
+
+@app.post("/encode_texts")
+async def encode_texts(
+    request: TextRequest,
+    token: str = Depends(verify_token),
+) -> Response:
+    embeddings = encoder.encode_text(request.texts)
+    response = Response(embeddings=embeddings)
+
+    return response
+
+
+@app.post("/encode_images")
+async def encode_images(
+    request: ImageRequest,
+    token: str = Depends(verify_token),
+) -> Response:
+    try:
+        images = request.download()
+        embeddings = encoder.encode_images(images)
+        return Response(embeddings=embeddings)
+
+    finally:
+        success = delete_images(images)
+        if not success:
+            print("Failed to delete images")
+
+        app.state.req_count += 1
+
+        if app.state.req_count % COLLECT_GC_EVERY == 0:
+            gc.collect()

requirements.txt

@@ -0,0 +1,10 @@
+torch==2.6.0
+transformers==4.37.2
+datasets==2.16.1
+open-clip-torch>=2.23.0
+huggingface-hub>=0.20.3
+fastapi==0.110.0
+uvicorn==0.27.1
+pydantic==2.6.3
+python-decouple
+numpy==1.24.3

runtime.txt

@@ -0,0 +1 @@
+python-3.9.6

src/auth.py

@@ -0,0 +1,17 @@
+from fastapi import HTTPException, Security
+from fastapi.security import HTTPBearer, HTTPAuthorizationCredentials
+from decouple import config
+
+
+API_TOKEN = config("API_TOKEN")
+security = HTTPBearer()
+
+
+def verify_token(credentials: HTTPAuthorizationCredentials = Security(security)):
+    if credentials.credentials != API_TOKEN:
+        raise HTTPException(
+            status_code=401,
+            detail="Invalid authentication credentials",
+            headers={"WWW-Authenticate": "Bearer"},
+        )
+    return credentials.credentials

src/encoder.py

@@ -0,0 +1,60 @@
+from typing import List
+from PIL.Image import Image
+
+import torch
+from transformers import AutoModel, AutoProcessor
+
+from .utils import normalize_vectors
+
+
+MODEL_NAME = "Marqo/marqo-fashionCLIP"
+
+
+class FashionCLIPEncoder:
+    def __init__(self, normalize: bool = False):
+        self.normalize = normalize
+
+        self.device = torch.device("cpu")
+
+        self.processor = AutoProcessor.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+        )
+
+        self.model = AutoModel.from_pretrained(
+            MODEL_NAME,
+            trust_remote_code=True,
+        )
+
+        self.model.to(self.device)
+        self.model.eval()
+
+    def encode_text(self, texts: List[str]) -> List[List[float]]:
+        kwargs = {
+            "padding": "max_length",
+            "return_tensors": "pt",
+            "truncation": True,
+        }
+
+        inputs = self.processor(text=texts, **kwargs)
+
+        with torch.no_grad():
+            batch = {k: v.to(self.device) for k, v in inputs.items()}
+            vectors = self.model.get_text_features(**batch)
+
+            return self._postprocess_vectors(vectors)
+
+    def encode_images(self, images: List[Image]) -> List[List[float]]:
+        inputs = self.processor(images=images, return_tensors="pt")
+
+        with torch.no_grad():
+            batch = {k: v.to(self.device) for k, v in inputs.items()}
+            vectors = self.model.get_image_features(**batch)
+
+            return self._postprocess_vectors(vectors)
+
+    def _postprocess_vectors(self, vectors: torch.Tensor) -> List[List[float]]:
+        if self.normalize:
+            vectors = normalize_vectors(vectors)
+
+        return vectors.detach().cpu().numpy().tolist()

src/models.py

@@ -0,0 +1,40 @@
+from pydantic import BaseModel, validator
+from typing import List
+from PIL.Image import Image
+
+from .utils import download_image_as_pil
+
+
+BATCH_SIZE_TEXT: int = 128
+BATCH_SIZE_IMAGE: int = 64
+
+
+class TextRequest(BaseModel):
+    texts: List[str]
+
+    @validator("texts")
+    def validate_texts_batch_size(cls, v):
+        if len(v) > BATCH_SIZE_TEXT:
+            raise ValueError(f"Maximum batch size for texts is {BATCH_SIZE_TEXT}")
+        if len(v) == 0:
+            raise ValueError("At least one text is required")
+        return v
+
+
+class ImageRequest(BaseModel):
+    urls: List[str]
+
+    @validator("urls")
+    def validate_images_batch_size(cls, v):
+        if len(v) > BATCH_SIZE_IMAGE:
+            raise ValueError(f"Maximum batch size for images is {BATCH_SIZE_IMAGE}")
+        if len(v) == 0:
+            raise ValueError("At least one image URL is required")
+        return v
+
+    def download(self) -> List[Image]:
+        return [download_image_as_pil(url) for url in self.urls]
+
+
+class Response(BaseModel):
+    embeddings: List[List[float]]

src/utils.py

@@ -0,0 +1,90 @@
+from typing import Dict, List
+
+import requests, torch
+from PIL import Image
+
+
+REQUESTS_HEADERS = {
+    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+}
+
+
+def download_image_as_pil(url: str, timeout: int = 10) -> Image.Image:
+    try:
+        response = requests.get(
+            url, stream=True, headers=REQUESTS_HEADERS, timeout=timeout
+        )
+
+        if response.status_code == 200:
+            return Image.open(response.raw)
+
+    except Exception as e:
+        return
+
+
+def delete_images(images: List[Image.Image]) -> bool:
+    try:
+        for image in images:
+            if hasattr(image, "close"):
+                image.close()
+        success = True
+
+    except Exception:
+        success = False
+
+    del images
+
+    return success
+
+
+def normalize_vectors(vectors: torch.Tensor) -> torch.Tensor:
+    norms = torch.norm(vectors, p=2, dim=1, keepdim=True)
+    norms = torch.norm(vectors, p=2, dim=1, keepdim=True)
+    norms = torch.where(norms > 1e-8, norms, torch.ones_like(norms))
+    normalized_vectors = vectors / norms
+
+    return normalized_vectors
+
+
+def analyze_model_parameters(model: torch.nn.Module) -> Dict:
+    total_params = 0
+    param_types = set()
+    param_type_counts = {}
+
+    for param in model.parameters():
+        total_params += param.numel()
+        dtype = param.dtype
+        param_types.add(dtype)
+        param_type_counts[dtype] = param_type_counts.get(dtype, 0) + param.numel()
+
+    results = {
+        "total_params": total_params,
+        "param_types": {},
+        "device_info": {
+            "device": next(model.parameters()).device,
+            "cuda_available": torch.cuda.is_available(),
+        },
+    }
+
+    for dtype in param_types:
+        count = param_type_counts[dtype]
+        percentage = (count / total_params) * 100
+        memory_bytes = count * torch.finfo(dtype).bits // 8
+        memory_mb = memory_bytes / (1024 * 1024)
+
+        results["param_types"][str(dtype)] = {
+            "count": count,
+            "percentage": percentage,
+            "memory_mb": memory_mb,
+        }
+
+    if torch.cuda.is_available():
+        results["device_info"].update(
+            {
+                "cuda_device": torch.cuda.get_device_name(0),
+                "cuda_memory_allocated_mb": torch.cuda.memory_allocated(0) / 1024**2,
+                "cuda_memory_cached_mb": torch.cuda.memory_reserved(0) / 1024**2,
+            }
+        )
+
+    return results