Upload 10 files

.dockerignore

@@ -0,0 +1,69 @@
+# Git
+.git
+.gitignore
+
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Test files
+test_client.py
+hf_client.py
+start_server.py
+test_image.jpg
+sample_images/
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/
+
+# Documentation
+README.md

.gitignore

@@ -0,0 +1,134 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# pyenv
+.python-version
+
+# celery beat schedule file
+celerybeat-schedule
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS
+.DS_Store
+.DS_Store?
+._*
+.Spotlight-V100
+.Trashes
+ehthumbs.db
+Thumbs.db
+
+# Model files (if you have local models)
+*.safetensors
+*.bin
+*.pt
+*.pth
+
+# Test images
+test_image.jpg
+sample_images/
+
+# Logs
+*.log
+logs/
+
+# Temporary files
+tmp/
+temp/

Dockerfile

@@ -0,0 +1,47 @@
+# Use Python 3.9 slim image as base
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    libgl1-mesa-glx \
+    libglib2.0-0 \
+    libsm6 \
+    libxext6 \
+    libxrender-dev \
+    libgomp1 \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Create models directory
+RUN mkdir -p /app/models
+
+# Copy model files
+COPY *.safetensors /app/models/
+
+# Copy application code
+COPY app.py .
+
+# Create a non-root user for security
+RUN useradd -m -u 1000 appuser && chown -R appuser:appuser /app
+USER appuser
+
+# Expose port (Hugging Face Spaces uses port 7860)
+EXPOSE 7860
+
+# Health check
+HEALTHCHECK --interval=30s --timeout=30s --start-period=5s --retries=3 \
+    CMD curl -f http://localhost:7860/health || exit 1
+
+# Run the application
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,295 @@
----
-title: Chatgpt Oasis
-emoji: 🐨
-colorFrom: gray
-colorTo: indigo
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# ChatGPT Oasis Model Inference API - Hugging Face Spaces (Docker)
+
+A FastAPI-based inference server for vision models (Oasis 500M and ViT-L-20) deployed on Hugging Face Spaces using Docker SDK with local model files.
+
+## 🚀 Live Demo
+
+This API is deployed on Hugging Face Spaces and can be accessed at:
+```
+https://your-username-chatgpt-oasis.hf.space
+```
+
+## 📋 API Endpoints
+
+### Base URL
+```
+https://your-username-chatgpt-oasis.hf.space
+```
+
+### Available Endpoints
+
+#### 1. API Information
+- **GET** `/`
+- Returns API information and usage instructions
+
+#### 2. Health Check
+- **GET** `/health`
+- Returns server health status, model loading status, and model file presence
+
+#### 3. List Models
+- **GET** `/models`
+- Returns information about available models and their file status
+
+#### 4. Inference (Base64)
+- **POST** `/inference`
+- Accepts base64 encoded images
+- Request body:
+  ```json
+  {
+    "image": "base64_encoded_image_string",
+    "model_name": "oasis500m"  // or "vit-l-20"
+  }
+  ```
+
+#### 5. Inference (File Upload)
+- **POST** `/upload_inference`
+- Accepts image file uploads
+- Form data:
+  - `file`: Image file
+  - `model_name`: Model to use (optional, defaults to "oasis500m")
+
+#### 6. Simple Prediction (Gradio Compatible)
+- **POST** `/predict`
+- Simple file upload endpoint for easy integration
+
+## 🔧 Usage Examples
+
+### Using Python Requests
+
+```python
+import requests
+import base64
+from PIL import Image
+import io
+
+# Your Hugging Face Spaces URL
+SPACE_URL = "https://your-username-chatgpt-oasis.hf.space"
+
+# Method 1: File Upload
+def predict_with_file_upload(image_path, model_name="oasis500m"):
+    with open(image_path, 'rb') as f:
+        files = {'file': f}
+        data = {'model_name': model_name}
+        
+        response = requests.post(
+            f"{SPACE_URL}/upload_inference",
+            files=files,
+            data=data,
+            timeout=120
+        )
+        return response.json()
+
+# Method 2: Base64 Encoding
+def predict_with_base64(image_path, model_name="oasis500m"):
+    # Load and encode image
+    image = Image.open(image_path)
+    buffer = io.BytesIO()
+    image.save(buffer, format="JPEG")
+    image_base64 = base64.b64encode(buffer.getvalue()).decode()
+    
+    # Make request
+    response = requests.post(
+        f"{SPACE_URL}/inference",
+        json={
+            "image": image_base64,
+            "model_name": model_name
+        },
+        timeout=120
+    )
+    return response.json()
+
+# Example usage
+result = predict_with_file_upload("your_image.jpg", "oasis500m")
+print(result)
+```
+
+### Using cURL
+
+```bash
+# File upload inference
+curl -X POST "https://your-username-chatgpt-oasis.hf.space/upload_inference" \
+  -H "accept: application/json" \
+  -F "file=@your_image.jpg" \
+  -F "model_name=oasis500m"
+
+# Health check
+curl "https://your-username-chatgpt-oasis.hf.space/health"
+
+# API documentation
+curl "https://your-username-chatgpt-oasis.hf.space/docs"
+```
+
+### Using JavaScript/Fetch
+
+```javascript
+// File upload inference
+async function predictImage(file, modelName = 'oasis500m') {
+    const formData = new FormData();
+    formData.append('file', file);
+    formData.append('model_name', modelName);
+    
+    const response = await fetch('https://your-username-chatgpt-oasis.hf.space/upload_inference', {
+        method: 'POST',
+        body: formData
+    });
+    
+    return await response.json();
+}
+
+// Base64 inference
+async function predictImageBase64(imageBase64, modelName = 'oasis500m') {
+    const response = await fetch('https://your-username-chatgpt-oasis.hf.space/inference', {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            image: imageBase64,
+            model_name: modelName
+        })
+    });
+    
+    return await response.json();
+}
+```
+
+## 📊 Response Format
+
+All inference endpoints return the same response format:
+
+```json
+{
+  "predictions": [
+    {
+      "label": "predicted_class_name",
+      "confidence": 0.95
+    },
+    {
+      "label": "second_predicted_class",
+      "confidence": 0.03
+    }
+  ],
+  "model_used": "oasis500m",
+  "confidence_scores": [0.95, 0.03, 0.01, 0.005, 0.005]
+}
+```
+
+## 🤖 Available Models
+
+### Oasis 500M
+- **Type**: Vision Transformer
+- **Size**: ~500M parameters
+- **File**: `oasis500m.safetensors`
+- **Use Case**: General image classification
+- **Performance**: High accuracy on ImageNet
+
+### ViT-L-20
+- **Type**: Vision Transformer Large
+- **Size**: ~300M parameters  
+- **File**: `vit-l-20.safetensors`
+- **Use Case**: High-performance image classification
+- **Performance**: State-of-the-art on many benchmarks
+
+## 🔍 API Documentation
+
+Once deployed, you can access:
+- **Interactive API Docs**: `https://your-username-chatgpt-oasis.hf.space/docs`
+- **Alternative API Docs**: `https://your-username-chatgpt-oasis.hf.space/redoc`
+
+## 🚀 Deployment on Hugging Face Spaces (Docker SDK)
+
+### Prerequisites
+1. Hugging Face account
+2. Local model files (`.safetensors`)
+3. Git repository with your code
+
+### Steps to Deploy
+
+1. **Create a new Space on Hugging Face**
+   - Go to [Hugging Face Spaces](https://huggingface.co/spaces)
+   - Click "Create new Space"
+   - Choose **"Docker"** as the SDK
+   - Set visibility (public/private)
+
+2. **Prepare your files**
+   - `Dockerfile` - Container configuration
+   - `app.py` - Main FastAPI application
+   - `requirements.txt` - Python dependencies
+   - `README.md` - This documentation
+   - `oasis500m.safetensors` - Oasis model weights
+   - `vit-l-20.safetensors` - ViT model weights
+
+3. **Upload files to your Space**
+   - Upload all files to the Space repository
+   - The Dockerfile will copy the model files into the container
+
+4. **Configure the Space**
+   - Set appropriate hardware requirements (CPU/GPU)
+   - Ensure sufficient memory for model loading
+
+5. **Deploy**
+   - Push your code to the Space repository
+   - Hugging Face will automatically build the Docker image and deploy
+
+### Space Configuration
+
+Your Space will need:
+- **Hardware**: CPU (or GPU for faster inference)
+- **Memory**: At least 8GB RAM (for both models)
+- **Storage**: Sufficient space for model files (~3GB)
+
+## 📁 File Structure
+
+```
+your-space/
+├── Dockerfile              # Container configuration
+├── app.py                  # FastAPI application
+├── requirements.txt        # Python dependencies
+├── README.md              # Documentation
+├── .dockerignore          # Docker ignore file
+├── oasis500m.safetensors  # Oasis model weights
+└── vit-l-20.safetensors   # ViT model weights
+```
+
+## ⚡ Performance Tips
+
+- **Model Loading**: Models are loaded once when the container starts
+- **Local Files**: Using local `.safetensors` files avoids download time
+- **Caching**: Consider implementing response caching for repeated requests
+- **Batch Processing**: For multiple images, send them sequentially
+- **Image Size**: Optimize image size before sending (models expect specific dimensions)
+
+## 🔧 Troubleshooting
+
+### Common Issues
+
+1. **Model Loading Time**
+   - First request may take longer as models load from local files
+   - Check `/health` endpoint for model status
+
+2. **Memory Issues**
+   - Use smaller images
+   - Process one image at a time
+   - Consider using only one model at a time
+
+3. **Model File Issues**
+   - Ensure `.safetensors` files are uploaded to the Space
+   - Check `/health` endpoint for file presence status
+
+4. **Timeout Errors**
+   - Increase timeout settings in your client
+   - Check Space logs for errors
+
+### Getting Help
+
+- Check the Space logs in Hugging Face dashboard
+- Use the `/health` endpoint to verify model and file status
+- Test with the `/docs` interactive interface
+
+## 📝 License
+
+This project is for inference purposes. Please respect the licenses of the underlying models (Oasis and ViT).
+
+## 🤝 Contributing
+
+Feel free to submit issues and enhancement requests!

app.py

@@ -0,0 +1,285 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import torch
+import torch.nn.functional as F
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import io
+import numpy as np
+from typing import List, Dict, Any
+import logging
+import os
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="ChatGPT Oasis Model Inference API",
+    description="FastAPI inference server for Oasis and ViT models deployed on Hugging Face Spaces with Docker",
+    version="1.0.0"
+)
+
+# Global variables to store loaded models
+oasis_model = None
+oasis_processor = None
+vit_model = None
+vit_processor = None
+
+class InferenceRequest(BaseModel):
+    image: str  # Base64 encoded image
+    model_name: str = "oasis500m"  # Default to oasis model
+
+class InferenceResponse(BaseModel):
+    predictions: List[Dict[str, Any]]
+    model_used: str
+    confidence_scores: List[float]
+
+def load_models():
+    """Load both models from local files"""
+    global oasis_model, oasis_processor, vit_model, vit_processor
+    
+    try:
+        logger.info("Loading Oasis 500M model from local files...")
+        # Load Oasis model from local files
+        oasis_processor = AutoImageProcessor.from_pretrained("microsoft/oasis-500m")
+        oasis_model = AutoModelForImageClassification.from_pretrained(
+            "microsoft/oasis-500m",
+            local_files_only=False  # Will download config but use local weights
+        )
+        
+        # Load local weights if available
+        oasis_model_path = "/app/models/oasis500m.safetensors"
+        if os.path.exists(oasis_model_path):
+            logger.info("Loading Oasis weights from local file...")
+            from safetensors.torch import load_file
+            state_dict = load_file(oasis_model_path)
+            oasis_model.load_state_dict(state_dict, strict=False)
+        
+        oasis_model.eval()
+        
+        logger.info("Loading ViT-L-20 model from local files...")
+        # Load ViT model from local files
+        vit_processor = AutoImageProcessor.from_pretrained("google/vit-large-patch16-224")
+        vit_model = AutoModelForImageClassification.from_pretrained(
+            "google/vit-large-patch16-224",
+            local_files_only=False  # Will download config but use local weights
+        )
+        
+        # Load local weights if available
+        vit_model_path = "/app/models/vit-l-20.safetensors"
+        if os.path.exists(vit_model_path):
+            logger.info("Loading ViT weights from local file...")
+            from safetensors.torch import load_file
+            state_dict = load_file(vit_model_path)
+            vit_model.load_state_dict(state_dict, strict=False)
+        
+        vit_model.eval()
+        
+        logger.info("All models loaded successfully!")
+        
+    except Exception as e:
+        logger.error(f"Error loading models: {e}")
+        raise e
+
+@app.on_event("startup")
+async def startup_event():
+    """Load models when the application starts"""
+    load_models()
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "ChatGPT Oasis Model Inference API",
+        "version": "1.0.0",
+        "deployed_on": "Hugging Face Spaces (Docker)",
+        "available_models": ["oasis500m", "vit-l-20"],
+        "endpoints": {
+            "health": "/health",
+            "inference": "/inference",
+            "upload_inference": "/upload_inference",
+            "predict": "/predict"
+        },
+        "usage": {
+            "base64_inference": "POST /inference with JSON body containing 'image' (base64) and 'model_name'",
+            "file_upload": "POST /upload_inference with multipart form containing 'file' and optional 'model_name'",
+            "simple_predict": "POST /predict with file upload for quick inference"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    models_status = {
+        "oasis500m": oasis_model is not None,
+        "vit-l-20": vit_model is not None
+    }
+    
+    # Check if model files exist
+    model_files = {
+        "oasis500m": os.path.exists("/app/models/oasis500m.safetensors"),
+        "vit-l-20": os.path.exists("/app/models/vit-l-20.safetensors")
+    }
+    
+    return {
+        "status": "healthy",
+        "models_loaded": models_status,
+        "model_files_present": model_files,
+        "deployment": "huggingface-spaces-docker"
+    }
+
+def process_image_with_model(image: Image.Image, model_name: str):
+    """Process image with the specified model"""
+    if model_name == "oasis500m":
+        if oasis_model is None or oasis_processor is None:
+            raise HTTPException(status_code=500, detail="Oasis model not loaded")
+        
+        inputs = oasis_processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = oasis_model(**inputs)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)
+            
+        # Get top predictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        predictions = []
+        for i in range(top_indices.shape[1]):
+            pred = {
+                "label": oasis_model.config.id2label[top_indices[0][i].item()],
+                "confidence": top_probs[0][i].item()
+            }
+            predictions.append(pred)
+            
+        return predictions
+        
+    elif model_name == "vit-l-20":
+        if vit_model is None or vit_processor is None:
+            raise HTTPException(status_code=500, detail="ViT model not loaded")
+        
+        inputs = vit_processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = vit_model(**inputs)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)
+            
+        # Get top predictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        predictions = []
+        for i in range(top_indices.shape[1]):
+            pred = {
+                "label": vit_model.config.id2label[top_indices[0][i].item()],
+                "confidence": top_probs[0][i].item()
+            }
+            predictions.append(pred)
+            
+        return predictions
+    
+    else:
+        raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
+
+@app.post("/inference", response_model=InferenceResponse)
+async def inference(request: InferenceRequest):
+    """Inference endpoint using base64 encoded image"""
+    try:
+        import base64
+        
+        # Decode base64 image
+        image_data = base64.b64decode(request.image)
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Process with model
+        predictions = process_image_with_model(image, request.model_name)
+        
+        # Extract confidence scores
+        confidence_scores = [pred["confidence"] for pred in predictions]
+        
+        return InferenceResponse(
+            predictions=predictions,
+            model_used=request.model_name,
+            confidence_scores=confidence_scores
+        )
+        
+    except Exception as e:
+        logger.error(f"Inference error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/upload_inference", response_model=InferenceResponse)
+async def upload_inference(
+    file: UploadFile = File(...),
+    model_name: str = "oasis500m"
+):
+    """Inference endpoint using file upload"""
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Read and process image
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Process with model
+        predictions = process_image_with_model(image, model_name)
+        
+        # Extract confidence scores
+        confidence_scores = [pred["confidence"] for pred in predictions]
+        
+        return InferenceResponse(
+            predictions=predictions,
+            model_used=model_name,
+            confidence_scores=confidence_scores
+        )
+        
+    except Exception as e:
+        logger.error(f"Upload inference error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/models")
+async def list_models():
+    """List available models and their status"""
+    return {
+        "available_models": [
+            {
+                "name": "oasis500m",
+                "description": "Oasis 500M vision model",
+                "loaded": oasis_model is not None,
+                "file_present": os.path.exists("/app/models/oasis500m.safetensors")
+            },
+            {
+                "name": "vit-l-20",
+                "description": "Vision Transformer Large model",
+                "loaded": vit_model is not None,
+                "file_present": os.path.exists("/app/models/vit-l-20.safetensors")
+            }
+        ]
+    }
+
+# Hugging Face Spaces specific endpoint for Gradio compatibility
+@app.post("/predict")
+async def predict(file: UploadFile = File(...)):
+    """Simple prediction endpoint for Hugging Face Spaces integration"""
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Read and process image
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Process with default model (oasis500m)
+        predictions = process_image_with_model(image, "oasis500m")
+        
+        # Return simplified format for Gradio
+        return {
+            "predictions": predictions[:3],  # Top 3 predictions
+            "model_used": "oasis500m"
+        }
+        
+    except Exception as e:
+        logger.error(f"Predict error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))

hf_client.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+"""
+Client for testing the ChatGPT Oasis Model Inference API deployed on Hugging Face Spaces
+"""
+
+import requests
+import base64
+import json
+from PIL import Image
+import io
+import os
+import time
+
+class HuggingFaceSpacesClient:
+    def __init__(self, space_url):
+        """
+        Initialize the client with your Hugging Face Space URL
+        
+        Args:
+            space_url (str): Your Space URL (e.g., "https://your-username-chatgpt-oasis.hf.space")
+        """
+        self.base_url = space_url.rstrip('/')
+        
+    def health_check(self):
+        """Check if the API is healthy and models are loaded"""
+        try:
+            response = requests.get(f"{self.base_url}/health", timeout=30)
+            print(f"Health Check Status: {response.status_code}")
+            print(f"Response: {json.dumps(response.json(), indent=2)}")
+            return response.status_code == 200
+        except Exception as e:
+            print(f"Health check error: {e}")
+            return False
+    
+    def list_models(self):
+        """Get information about available models"""
+        try:
+            response = requests.get(f"{self.base_url}/models", timeout=30)
+            print(f"Models Status: {response.status_code}")
+            print(f"Available Models: {json.dumps(response.json(), indent=2)}")
+            return response.json()
+        except Exception as e:
+            print(f"Models list error: {e}")
+            return None
+    
+    def predict_file_upload(self, image_path, model_name="oasis500m"):
+        """
+        Predict using file upload
+        
+        Args:
+            image_path (str): Path to the image file
+            model_name (str): Model to use ("oasis500m" or "vit-l-20")
+        """
+        if not os.path.exists(image_path):
+            print(f"Image file not found: {image_path}")
+            return None
+            
+        try:
+            with open(image_path, 'rb') as f:
+                files = {'file': (os.path.basename(image_path), f, 'image/jpeg')}
+                data = {'model_name': model_name}
+                
+                print(f"Uploading {image_path} to {model_name}...")
+                response = requests.post(
+                    f"{self.base_url}/upload_inference",
+                    files=files,
+                    data=data,
+                    timeout=120
+                )
+                
+                print(f"Status: {response.status_code}")
+                if response.status_code == 200:
+                    result = response.json()
+                    print(f"Model used: {result['model_used']}")
+                    print("Top 3 predictions:")
+                    for i, pred in enumerate(result['predictions'][:3]):
+                        print(f"  {i+1}. {pred['label']} ({pred['confidence']:.3f})")
+                    return result
+                else:
+                    print(f"Error: {response.text}")
+                    return None
+                    
+        except Exception as e:
+            print(f"File upload prediction error: {e}")
+            return None
+    
+    def predict_base64(self, image_path, model_name="oasis500m"):
+        """
+        Predict using base64 encoded image
+        
+        Args:
+            image_path (str): Path to the image file
+            model_name (str): Model to use ("oasis500m" or "vit-l-20")
+        """
+        if not os.path.exists(image_path):
+            print(f"Image file not found: {image_path}")
+            return None
+            
+        try:
+            # Load and encode image
+            image = Image.open(image_path)
+            buffer = io.BytesIO()
+            image.save(buffer, format="JPEG")
+            image_base64 = base64.b64encode(buffer.getvalue()).decode()
+            
+            print(f"Encoding {image_path} and sending to {model_name}...")
+            response = requests.post(
+                f"{self.base_url}/inference",
+                json={
+                    "image": image_base64,
+                    "model_name": model_name
+                },
+                headers={"Content-Type": "application/json"},
+                timeout=120
+            )
+            
+            print(f"Status: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Model used: {result['model_used']}")
+                print("Top 3 predictions:")
+                for i, pred in enumerate(result['predictions'][:3]):
+                    print(f"  {i+1}. {pred['label']} ({pred['confidence']:.3f})")
+                return result
+            else:
+                print(f"Error: {response.text}")
+                return None
+                
+        except Exception as e:
+            print(f"Base64 prediction error: {e}")
+            return None
+    
+    def create_test_image(self, output_path="test_image.jpg"):
+        """Create a simple test image for testing"""
+        # Create a simple colored rectangle
+        img = Image.new('RGB', (224, 224), color='red')
+        img.save(output_path, format='JPEG')
+        print(f"Test image created: {output_path}")
+        return output_path
+    
+    def test_all_endpoints(self, image_path=None):
+        """Test all endpoints with a given image or create a test image"""
+        print("=" * 60)
+        print("ChatGPT Oasis Model Inference API - Hugging Face Spaces Test")
+        print("=" * 60)
+        
+        # Test health check
+        print("\n1. Testing health check...")
+        if not self.health_check():
+            print("❌ Health check failed. Make sure your Space is running!")
+            return
+        
+        # Test models list
+        print("\n2. Testing models list...")
+        self.list_models()
+        
+        # Use provided image or create test image
+        if image_path is None:
+            print("\n3. Creating test image...")
+            image_path = self.create_test_image()
+        else:
+            print(f"\n3. Using provided image: {image_path}")
+        
+        # Test both models with file upload
+        print("\n4. Testing file upload inference...")
+        for model_name in ["oasis500m", "vit-l-20"]:
+            print(f"\n--- Testing {model_name} with file upload ---")
+            self.predict_file_upload(image_path, model_name)
+            time.sleep(2)  # Small delay between requests
+        
+        # Test both models with base64
+        print("\n5. Testing base64 inference...")
+        for model_name in ["oasis500m", "vit-l-20"]:
+            print(f"\n--- Testing {model_name} with base64 ---")
+            self.predict_base64(image_path, model_name)
+            time.sleep(2)  # Small delay between requests
+        
+        print("\n" + "=" * 60)
+        print("✅ Test completed!")
+
+def main():
+    """Main function to run the test client"""
+    
+    # Replace with your actual Hugging Face Space URL
+    SPACE_URL = "https://your-username-chatgpt-oasis.hf.space"
+    
+    # Initialize client
+    client = HuggingFaceSpacesClient(SPACE_URL)
+    
+    # Test with a specific image if provided
+    test_image = None  # Change this to a path like "your_image.jpg" if you have one
+    
+    # Run all tests
+    client.test_all_endpoints(test_image)
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,221 @@
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import torch
+import torch.nn.functional as F
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import io
+import numpy as np
+from typing import List, Dict, Any
+import logging
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="ChatGPT Oasis Model Inference API",
+    description="FastAPI inference server for Oasis and ViT models",
+    version="1.0.0"
+)
+
+# Global variables to store loaded models
+oasis_model = None
+oasis_processor = None
+vit_model = None
+vit_processor = None
+
+class InferenceRequest(BaseModel):
+    image: str  # Base64 encoded image
+    model_name: str = "oasis500m"  # Default to oasis model
+
+class InferenceResponse(BaseModel):
+    predictions: List[Dict[str, Any]]
+    model_used: str
+    confidence_scores: List[float]
+
+def load_models():
+    """Load both models into memory"""
+    global oasis_model, oasis_processor, vit_model, vit_processor
+    
+    try:
+        logger.info("Loading Oasis 500M model...")
+        # Load Oasis model
+        oasis_processor = AutoImageProcessor.from_pretrained("microsoft/oasis-500m")
+        oasis_model = AutoModelForImageClassification.from_pretrained("microsoft/oasis-500m")
+        oasis_model.eval()
+        
+        logger.info("Loading ViT-L-20 model...")
+        # Load ViT model
+        vit_processor = AutoImageProcessor.from_pretrained("google/vit-large-patch16-224")
+        vit_model = AutoModelForImageClassification.from_pretrained("google/vit-large-patch16-224")
+        vit_model.eval()
+        
+        logger.info("All models loaded successfully!")
+        
+    except Exception as e:
+        logger.error(f"Error loading models: {e}")
+        raise e
+
+@app.on_event("startup")
+async def startup_event():
+    """Load models when the application starts"""
+    load_models()
+
+@app.get("/")
+async def root():
+    """Root endpoint with API information"""
+    return {
+        "message": "ChatGPT Oasis Model Inference API",
+        "version": "1.0.0",
+        "available_models": ["oasis500m", "vit-l-20"],
+        "endpoints": {
+            "health": "/health",
+            "inference": "/inference",
+            "upload_inference": "/upload_inference"
+        }
+    }
+
+@app.get("/health")
+async def health_check():
+    """Health check endpoint"""
+    models_status = {
+        "oasis500m": oasis_model is not None,
+        "vit-l-20": vit_model is not None
+    }
+    
+    return {
+        "status": "healthy",
+        "models_loaded": models_status
+    }
+
+def process_image_with_model(image: Image.Image, model_name: str):
+    """Process image with the specified model"""
+    if model_name == "oasis500m":
+        if oasis_model is None or oasis_processor is None:
+            raise HTTPException(status_code=500, detail="Oasis model not loaded")
+        
+        inputs = oasis_processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = oasis_model(**inputs)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)
+            
+        # Get top predictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        predictions = []
+        for i in range(top_indices.shape[1]):
+            pred = {
+                "label": oasis_model.config.id2label[top_indices[0][i].item()],
+                "confidence": top_probs[0][i].item()
+            }
+            predictions.append(pred)
+            
+        return predictions
+        
+    elif model_name == "vit-l-20":
+        if vit_model is None or vit_processor is None:
+            raise HTTPException(status_code=500, detail="ViT model not loaded")
+        
+        inputs = vit_processor(images=image, return_tensors="pt")
+        with torch.no_grad():
+            outputs = vit_model(**inputs)
+            logits = outputs.logits
+            probabilities = F.softmax(logits, dim=-1)
+            
+        # Get top predictions
+        top_probs, top_indices = torch.topk(probabilities, 5)
+        
+        predictions = []
+        for i in range(top_indices.shape[1]):
+            pred = {
+                "label": vit_model.config.id2label[top_indices[0][i].item()],
+                "confidence": top_probs[0][i].item()
+            }
+            predictions.append(pred)
+            
+        return predictions
+    
+    else:
+        raise HTTPException(status_code=400, detail=f"Unknown model: {model_name}")
+
+@app.post("/inference", response_model=InferenceResponse)
+async def inference(request: InferenceRequest):
+    """Inference endpoint using base64 encoded image"""
+    try:
+        import base64
+        
+        # Decode base64 image
+        image_data = base64.b64decode(request.image)
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Process with model
+        predictions = process_image_with_model(image, request.model_name)
+        
+        # Extract confidence scores
+        confidence_scores = [pred["confidence"] for pred in predictions]
+        
+        return InferenceResponse(
+            predictions=predictions,
+            model_used=request.model_name,
+            confidence_scores=confidence_scores
+        )
+        
+    except Exception as e:
+        logger.error(f"Inference error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/upload_inference", response_model=InferenceResponse)
+async def upload_inference(
+    file: UploadFile = File(...),
+    model_name: str = "oasis500m"
+):
+    """Inference endpoint using file upload"""
+    try:
+        # Validate file type
+        if not file.content_type.startswith('image/'):
+            raise HTTPException(status_code=400, detail="File must be an image")
+        
+        # Read and process image
+        image_data = await file.read()
+        image = Image.open(io.BytesIO(image_data)).convert('RGB')
+        
+        # Process with model
+        predictions = process_image_with_model(image, model_name)
+        
+        # Extract confidence scores
+        confidence_scores = [pred["confidence"] for pred in predictions]
+        
+        return InferenceResponse(
+            predictions=predictions,
+            model_used=model_name,
+            confidence_scores=confidence_scores
+        )
+        
+    except Exception as e:
+        logger.error(f"Upload inference error: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.get("/models")
+async def list_models():
+    """List available models and their status"""
+    return {
+        "available_models": [
+            {
+                "name": "oasis500m",
+                "description": "Oasis 500M vision model",
+                "loaded": oasis_model is not None
+            },
+            {
+                "name": "vit-l-20",
+                "description": "Vision Transformer Large model",
+                "loaded": vit_model is not None
+            }
+        ]
+    }
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

requirements.txt

@@ -0,0 +1,10 @@
+fastapi==0.104.1
+uvicorn[standard]==0.24.0
+torch==2.1.0
+torchvision==0.16.0
+transformers==4.35.0
+safetensors==0.4.0
+Pillow==10.0.1
+python-multipart==0.0.6
+numpy==1.24.3
+pydantic==2.5.0

start_server.py

@@ -0,0 +1,47 @@
+#!/usr/bin/env python3
+"""
+Startup script for the ChatGPT Oasis Model Inference API
+"""
+
+import uvicorn
+import argparse
+import os
+import sys
+
+def main():
+    parser = argparse.ArgumentParser(description="Start the ChatGPT Oasis Model Inference API")
+    parser.add_argument("--host", default="0.0.0.0", help="Host to bind to (default: 0.0.0.0)")
+    parser.add_argument("--port", type=int, default=8000, help="Port to bind to (default: 8000)")
+    parser.add_argument("--reload", action="store_true", help="Enable auto-reload for development")
+    parser.add_argument("--workers", type=int, default=1, help="Number of worker processes (default: 1)")
+    parser.add_argument("--log-level", default="info", choices=["debug", "info", "warning", "error"], 
+                       help="Log level (default: info)")
+    
+    args = parser.parse_args()
+    
+    print("Starting ChatGPT Oasis Model Inference API...")
+    print(f"Host: {args.host}")
+    print(f"Port: {args.port}")
+    print(f"Workers: {args.workers}")
+    print(f"Log Level: {args.log_level}")
+    print(f"Auto-reload: {args.reload}")
+    print("-" * 50)
+    
+    # Check if main.py exists
+    if not os.path.exists("main.py"):
+        print("Error: main.py not found in current directory!")
+        sys.exit(1)
+    
+    # Start the server
+    uvicorn.run(
+        "main:app",
+        host=args.host,
+        port=args.port,
+        reload=args.reload,
+        workers=args.workers,
+        log_level=args.log_level,
+        access_log=True
+    )
+
+if __name__ == "__main__":
+    main()

test_client.py

@@ -0,0 +1,170 @@
+#!/usr/bin/env python3
+"""
+Test client for the ChatGPT Oasis Model Inference API
+"""
+
+import requests
+import base64
+import json
+from PIL import Image
+import io
+import os
+
+# API base URL
+BASE_URL = "http://localhost:8000"
+
+def test_health_check():
+    """Test the health check endpoint"""
+    print("Testing health check...")
+    try:
+        response = requests.get(f"{BASE_URL}/health")
+        print(f"Status: {response.status_code}")
+        print(f"Response: {json.dumps(response.json(), indent=2)}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def test_list_models():
+    """Test the models list endpoint"""
+    print("\nTesting models list...")
+    try:
+        response = requests.get(f"{BASE_URL}/models")
+        print(f"Status: {response.status_code}")
+        print(f"Response: {json.dumps(response.json(), indent=2)}")
+        return response.status_code == 200
+    except Exception as e:
+        print(f"Error: {e}")
+        return False
+
+def create_test_image():
+    """Create a simple test image"""
+    # Create a simple colored rectangle
+    img = Image.new('RGB', (224, 224), color='red')
+    
+    # Save to bytes
+    buffer = io.BytesIO()
+    img.save(buffer, format='JPEG')
+    buffer.seek(0)
+    
+    return buffer.getvalue()
+
+def test_base64_inference():
+    """Test inference with base64 encoded image"""
+    print("\nTesting base64 inference...")
+    
+    # Create test image
+    image_data = create_test_image()
+    image_base64 = base64.b64encode(image_data).decode()
+    
+    # Test both models
+    for model_name in ["oasis500m", "vit-l-20"]:
+        print(f"\nTesting {model_name}...")
+        try:
+            response = requests.post(
+                f"{BASE_URL}/inference",
+                json={
+                    "image": image_base64,
+                    "model_name": model_name
+                },
+                headers={"Content-Type": "application/json"}
+            )
+            print(f"Status: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Model used: {result['model_used']}")
+                print(f"Top prediction: {result['predictions'][0]}")
+            else:
+                print(f"Error: {response.text}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+def test_file_upload_inference():
+    """Test inference with file upload"""
+    print("\nTesting file upload inference...")
+    
+    # Create test image
+    image_data = create_test_image()
+    
+    # Test both models
+    for model_name in ["oasis500m", "vit-l-20"]:
+        print(f"\nTesting {model_name} with file upload...")
+        try:
+            files = {'file': ('test_image.jpg', image_data, 'image/jpeg')}
+            data = {'model_name': model_name}
+            
+            response = requests.post(
+                f"{BASE_URL}/upload_inference",
+                files=files,
+                data=data
+            )
+            print(f"Status: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Model used: {result['model_used']}")
+                print(f"Top prediction: {result['predictions'][0]}")
+            else:
+                print(f"Error: {response.text}")
+        except Exception as e:
+            print(f"Error: {e}")
+
+def test_with_real_image(image_path):
+    """Test with a real image file"""
+    if not os.path.exists(image_path):
+        print(f"Image file not found: {image_path}")
+        return
+    
+    print(f"\nTesting with real image: {image_path}")
+    
+    # Test file upload
+    try:
+        with open(image_path, 'rb') as f:
+            files = {'file': (os.path.basename(image_path), f, 'image/jpeg')}
+            data = {'model_name': 'oasis500m'}
+            
+            response = requests.post(
+                f"{BASE_URL}/upload_inference",
+                files=files,
+                data=data
+            )
+            print(f"Status: {response.status_code}")
+            if response.status_code == 200:
+                result = response.json()
+                print(f"Model used: {result['model_used']}")
+                print("Top 3 predictions:")
+                for i, pred in enumerate(result['predictions'][:3]):
+                    print(f"  {i+1}. {pred['label']} ({pred['confidence']:.3f})")
+            else:
+                print(f"Error: {response.text}")
+    except Exception as e:
+        print(f"Error: {e}")
+
+def main():
+    """Run all tests"""
+    print("ChatGPT Oasis Model Inference API - Test Client")
+    print("=" * 50)
+    
+    # Test basic endpoints
+    health_ok = test_health_check()
+    models_ok = test_list_models()
+    
+    if not health_ok:
+        print("Health check failed. Make sure the server is running!")
+        return
+    
+    # Test inference endpoints
+    test_base64_inference()
+    test_file_upload_inference()
+    
+    # Test with real image if available
+    test_images = ["test.jpg", "sample.jpg", "image.jpg"]
+    for img in test_images:
+        if os.path.exists(img):
+            test_with_real_image(img)
+            break
+    
+    print("\n" + "=" * 50)
+    print("Test completed!")
+
+if __name__ == "__main__":
+    main()