push

.dockerignore

@@ -0,0 +1,20 @@
+__pycache__
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info
+dist
+build
+.git
+.gitignore
+.vscode
+.idea
+*.swp
+*.swo
+*~
+.DS_Store
+README.md
+.dockerignore

Dockerfile

@@ -0,0 +1,37 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    libhdf5-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+# Upgrade pip first
+RUN pip install --upgrade pip
+
+# Copy requirements and install lightweight packages first
+COPY requirements.txt .
+
+# Install packages separately to handle large downloads better
+RUN pip install --default-timeout=1000 --no-cache-dir fastapi[all] uvicorn[standard] pydantic
+
+# Install TensorFlow CPU (smaller and faster to download than GPU version)
+RUN pip install --default-timeout=1000 --no-cache-dir tensorflow-cpu==2.15.0
+
+# Install remaining packages
+RUN pip install --default-timeout=1000 --no-cache-dir keras==2.15.0 numpy==1.26.4 pillow
+
+# Copy application code
+COPY app.py .
+
+# Copy model files
+COPY models/ ./models/
+
+# Expose port
+EXPOSE 8002
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "8002"]

README.md

@@ -1,10 +1,115 @@
----
-title: Basic Face Generator
-emoji: 🐠
-colorFrom: purple
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Face Generator FastAPI
+
+FastAPI service for the GAN-based face generation model.
+
+## Setup
+
+### Local Development
+
+1. Install dependencies:
+```bash
+pip install -r requirements.txt
+```
+
+2. Run the app:
+```bash
+python app.py
+# or
+uvicorn app:app --host 0.0.0.0 --port 8002 --reload
+```
+
+3. Access the API:
+- API: http://localhost:8002
+- Interactive docs: http://localhost:8002/docs
+- ReDoc: http://localhost:8002/redoc
+
+### Docker
+
+1. Build the image:
+```bash
+docker build -t facegen-api .
+```
+
+2. Run the container:
+```bash
+docker run -p 8002:8002 facegen-api
+```
+
+## API Endpoints
+
+### GET `/`
+Health check and info
+```bash
+curl http://localhost:8002/
+```
+
+### GET `/health`
+Detailed health status
+```bash
+curl http://localhost:8002/health
+```
+
+### POST `/generate`
+Generate face images (returns PNG image)
+
+Request body:
+```json
+{
+  "n_samples": 4,
+  "seed": 42
+}
+```
+
+Example:
+```bash
+# Generate single face
+curl -X POST http://localhost:8002/generate \
+  -H "Content-Type: application/json" \
+  -d '{"n_samples": 1, "seed": 42}' \
+  --output face.png
+
+# Generate 4 faces in a grid
+curl -X POST http://localhost:8002/generate \
+  -H "Content-Type: application/json" \
+  -d '{"n_samples": 4, "seed": 123}' \
+  --output faces_grid.png
+```
+
+### GET `/generate-single`
+Quick endpoint to generate a single face
+
+Example:
+```bash
+# Random face
+curl http://localhost:8002/generate-single --output face.png
+
+# With seed
+curl "http://localhost:8002/generate-single?seed=42" --output face.png
+```
+
+## Model
+
+- **Model**: Face Generation GAN
+- **Location**: `./models/face-gen-gan`
+- **Type**: Generative Adversarial Network
+- **Port**: 8002
+
+## Parameters
+
+- **n_samples**: Number of faces to generate (1-16, default: 1)
+- **seed**: Random seed for reproducibility (optional)
+
+## Response Format
+
+- Returns PNG image
+- Single face: Original resolution
+- Multiple faces: Grid layout (auto-calculated)
+
+## Features
+
+- CORS enabled for all origins
+- Returns images as PNG
+- Grid layout for multiple faces
+- Reproducible generation with seeds
+- FastAPI automatic documentation
+- Health check endpoints

app.py

@@ -0,0 +1,126 @@
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import StreamingResponse
+from pydantic import BaseModel
+import numpy as np
+from keras.models import load_model
+from PIL import Image
+import io
+from typing import Optional
+
+app = FastAPI(title="Face Generator API", version="1.0.0")
+
+# Add CORS middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Global variables for model
+MODEL_PATH = "./models/face-gen-gan"
+model = None
+latent_dim = None
+
+# Request models
+class FaceGenRequest(BaseModel):
+    n_samples: Optional[int] = 1
+    seed: Optional[int] = None
+
+@app.on_event("startup")
+async def load_gan_model():
+    """Load the GAN model on startup"""
+    global model, latent_dim
+    print(f"Loading face generation GAN model from {MODEL_PATH}...")
+    
+    model = load_model(MODEL_PATH)
+    latent_dim = model.input_shape[1]
+    
+    print(f"Model loaded successfully! Latent dimension: {latent_dim}")
+
+@app.get("/")
+def root():
+    return {
+        "message": "Face Generator API",
+        "status": "running",
+        "model": "face-gen-gan",
+        "latent_dim": latent_dim
+    }
+
+@app.get("/health")
+def health():
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "latent_dim": latent_dim
+    }
+
+@app.post("/generate")
+async def generate_faces(request: FaceGenRequest):
+    """
+    Generate face images using the GAN model
+    Returns a PNG image (single face or grid of faces)
+    """
+    if model is None:
+        return {"error": "Model not loaded"}
+    
+    try:
+        # Validate n_samples
+        n_samples = max(1, min(request.n_samples, 16))  # Limit to 1-16
+        
+        # Set seed if provided
+        if request.seed is not None:
+            np.random.seed(request.seed)
+        
+        # Generate random latent points
+        latent_points = np.random.randn(n_samples, latent_dim)
+        
+        # Generate images
+        generated_images = model.predict(latent_points, verbose=0)
+        
+        # Scale from [-1, 1] to [0, 255]
+        generated_images = ((generated_images + 1) / 2.0 * 255).astype(np.uint8)
+        
+        if n_samples == 1:
+            # Single image
+            img = Image.fromarray(generated_images[0])
+        else:
+            # Create a grid
+            grid_size = int(np.ceil(np.sqrt(n_samples)))
+            img_height, img_width = generated_images.shape[1:3]
+            
+            # Create blank canvas
+            grid_img = np.ones((grid_size * img_height, grid_size * img_width, 3), dtype=np.uint8) * 255
+            
+            # Fill grid with generated images
+            for i in range(n_samples):
+                row = i // grid_size
+                col = i % grid_size
+                grid_img[row*img_height:(row+1)*img_height, 
+                        col*img_width:(col+1)*img_width] = generated_images[i]
+            
+            img = Image.fromarray(grid_img)
+        
+        # Convert to bytes
+        buf = io.BytesIO()
+        img.save(buf, format='PNG')
+        buf.seek(0)
+        
+        return StreamingResponse(buf, media_type="image/png")
+    
+    except Exception as e:
+        return {"error": str(e)}
+
+@app.get("/generate-single")
+async def generate_single_face(seed: Optional[int] = None):
+    """
+    Quick endpoint to generate a single face
+    """
+    request = FaceGenRequest(n_samples=1, seed=seed)
+    return await generate_faces(request)
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8002)

models/face-gen-gan/generator_model_100.h5

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd167921ef33931acace69054326314197b8bc340bd702503f167710f21f7235
+size 5563784

requirements.txt

@@ -0,0 +1,7 @@
+fastapi[all]
+uvicorn[standard]
+tensorflow-cpu==2.15.0
+keras==2.15.0
+numpy==1.26.4
+pillow
+pydantic