first commit

.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", "4"]

README.md

@@ -1,12 +1,46 @@
 ---
-title: Fclip
-emoji: 🚀
-colorFrom: blue
-colorTo: gray
+title: Fashionclip
+emoji: 🌖
+colorFrom: purple
+colorTo: yellow
 sdk: docker
 pinned: false
-license: mit
-short_description: Generate text & image embeddings for clothing items
+license: cc-by-nc-4.0
+short_description: Convert text to embeddings with FashionCLIP
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Install
+
+### Create SSH key
+
+```
+ls ~/.ssh/id_rsa.pub
+ssh-keygen -t rsa -b 4096 -C "[email protected]"
+cat ~/.ssh/id_rsa.pub
+```
+
+### Add key to HF SSH key settings
+
+### Clone project
+
+```
+git clone [email protected]:spaces/pdiot/fclip.git
+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,62 @@
+from fastapi import FastAPI, HTTPException, status, Security
+from fastapi.security import HTTPAuthorizationCredentials, HTTPBearer
+from decouple import config
+
+from src.encoder import FashionCLIPEncoder
+from src.models import TextRequest, ImageRequest, Response
+
+
+security = HTTPBearer()
+encoder = FashionCLIPEncoder()
+
+
+API_TOKEN = config("API_TOKEN")
+
+
+app = FastAPI()
+
+
+@app.get("/")
+async def root():
+    return {
+        "status": "ok",
+        "message": "FashionCLIP API is running",
+        "endpoints": {
+            "encode_texts": "POST /encode_texts - Get embeddings for text inputs",
+            "encode_images": "POST /encode_images - Get embeddings for image inputs",
+        },
+    }
+
+
+@app.post("/encode_texts")
+async def encode_texts(
+    request: TextRequest, credentials: HTTPAuthorizationCredentials = Security(security)
+) -> Response:
+    if credentials.credentials != API_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication token",
+        )
+
+    embeddings = encoder.encode_text(request.texts)
+    response = Response(embeddings=embeddings)
+
+    return response
+
+
+@app.post("/encode_images")
+async def encode_images(
+    request: ImageRequest,
+    credentials: HTTPAuthorizationCredentials = Security(security),
+) -> Response:
+    if credentials.credentials != API_TOKEN:
+        raise HTTPException(
+            status_code=status.HTTP_401_UNAUTHORIZED,
+            detail="Invalid authentication token",
+        )
+
+    images = request.download()
+    embeddings = encoder.encode_images(images)
+    response = Response(embeddings=embeddings)
+
+    return response

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+pydantic
+torch
+transformers
+open-clip-torch
+python-decouple

src/encoder.py

@@ -0,0 +1,48 @@
+from typing import List, Dict
+from PIL.Image import Image
+
+import torch
+from transformers import AutoModel, AutoProcessor
+
+
+MODEL_NAME = "Marqo/marqo-fashionCLIP"
+
+
+class FashionCLIPEncoder:
+    def __init__(self):
+        self.processor = AutoProcessor.from_pretrained(
+            MODEL_NAME, trust_remote_code=True
+        )
+        self.model = AutoModel.from_pretrained(MODEL_NAME, trust_remote_code=True)
+
+        self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = 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()}
+            return self._encode_text(batch)
+
+    def encode_images(self, images: List[Image]) -> List[List[float]]:
+        kwargs = {
+            "return_tensors": "pt",
+        }
+        inputs = self.processor(images=images, **kwargs)
+
+        with torch.no_grad():
+            batch = {k: v.to(self.device) for k, v in inputs.items()}
+            return self._encode_images(batch)
+
+    def _encode_text(self, batch: Dict) -> List[List[float]]:
+        return self.model.get_text_features(**batch).detach().cpu().numpy().tolist()
+
+    def _encode_images(self, batch: Dict) -> List[List[float]]:
+        return self.model.get_image_features(**batch).detach().cpu().numpy().tolist()

src/models.py

@@ -0,0 +1,20 @@
+from pydantic import BaseModel
+from typing import List
+from PIL.Image import Image
+
+from .utils import download_image_as_pil
+
+
+class TextRequest(BaseModel):
+    texts: List[str]
+
+
+class ImageRequest(BaseModel):
+    urls: List[str]
+
+    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,64 @@
+from typing import Dict
+
+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 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