Upload 4 files

Dockerfile

@@ -1,28 +1,11 @@
-FROM python:3.11-slim
+FROM python:3.9
 
-WORKDIR /app
+WORKDIR /code
 
-# Set cache directories BEFORE installing dependencies
-ENV HF_HOME=/tmp/.cache
-ENV TRANSFORMERS_CACHE=/tmp/.cache
-ENV TORCH_HOME=/tmp/.cache
+COPY ./requirements.txt /code/requirements.txt
 
-# Create cache directory
-RUN mkdir -p /tmp/.cache && chmod 777 /tmp/.cache
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# Install dependencies
-COPY requirements.txt requirements.txt
-RUN pip install --no-cache-dir -r requirements.txt
+COPY ./app.py /code/
 
-# Copy app
-COPY app.py app.py
-
-# Expose port
-EXPOSE 7860
-
-# Set environment
-ENV PORT=7860
-ENV PYTHONUNBUFFERED=1
-
-# Run app
-CMD ["python", "app.py"]
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,105 +1,123 @@
----
-title: Dog Breed Classification API
-emoji: 🐕
-colorFrom: blue
-colorTo: green
-sdk: docker
-app_port: 7860
-pinned: false
----
+# Dog Breed Classification API
 
-# 🐕 Dog Breed Classification API
+Bu Hugging Face Space, **Pavarissy/ConvNextV2-large-DogBreed** modelini kullanarak köpek ırkı sınıflandırması yapan bir FastAPI backend'idir.
 
-ConvNextV2-large-DogBreed model ile köpek ırkı tahmini yapan API.
+## 🚀 Kurulum Adımları
 
-## 🚀 Kullanım
+### 1. Hugging Face Space Oluşturma
 
-### Endpoint
+1. https://huggingface.co/spaces adresine gidin
+2. "Create new Space" butonuna tıklayın
+3. Space adını girin: `petbackend` (veya istediğiniz bir isim)
+4. SDK olarak **"Docker"** veya **"Gradio"** yerine **"Docker"** seçin (FastAPI için)
+5. Space'i oluşturun
 
-```
-POST /predict_pet
-```
+### 2. Dosyaları Yükleme
 
-### Request
+Space oluşturulduktan sonra, bu klasördeki dosyaları Space'e yükleyin:
 
-**Content-Type:** `multipart/form-data`
+- `app.py` - Ana FastAPI uygulaması
+- `requirements.txt` - Python bağımlılıkları
+- `Dockerfile` - Docker yapılandırması (aşağıda)
 
-**Body:**
-- `image` (file): Köpek fotoğrafı (JPEG, PNG, WebP)
+### 3. Dockerfile Oluşturma
 
-### Response
+Space'inize bir `Dockerfile` eklemeniz gerekiyor:
 
-```json
-{
-  "breed": "Doberman_pinscher",
-  "confidence": 0.533,
-  "top_5": [
-    {"breed": "Doberman_pinscher", "confidence": 0.533},
-    {"breed": "Beauceron", "confidence": 0.065},
-    {"breed": "German_pinscher", "confidence": 0.041},
-    {"breed": "Black_and_tan_coonhound", "confidence": 0.023},
-    {"breed": "Greater_swiss_mountain_dog", "confidence": 0.011}
-  ],
-  "model": "ConvNextV2-large-DogBreed",
-  "accuracy": "91.39%"
-}
+```dockerfile
+FROM python:3.9
+
+WORKDIR /code
+
+COPY ./requirements.txt /code/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+COPY ./app.py /code/
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]
 ```
 
-## 📝 Örnekler
+### 4. Alternatif: Gradio SDK Kullanımı
+
+Eğer Docker yerine Gradio SDK kullanmak isterseniz:
+
+1. Space oluştururken SDK olarak "Gradio" seçin
+2. Sadece `app.py` ve `requirements.txt` dosyalarını yükleyin
+3. Hugging Face otomatik olarak FastAPI'yi çalıştıracaktır
 
-### Python
+## 📡 API Endpoints
 
-```python
-import requests
+### GET /
+Ana endpoint - API durumunu gösterir
 
-url = "https://YOUR-SPACE-URL.hf.space/predict_pet"
+```bash
+curl https://alpingo23-petbackend.hf.space/
+```
+
+### POST /predict_pet
+Köpek ırkı tahmini yapar
+
+```bash
+curl -X POST https://alpingo23-petbackend.hf.space/predict_pet \
+  -F "image=@dog_image.jpg"
+```
 
-with open("dog.jpg", "rb") as f:
-    files = {"image": f}
-    response = requests.post(url, files=files)
-    
-result = response.json()
-print(f"Breed: {result['breed']}")
-print(f"Confidence: {result['confidence']:.2%}")
+**Response Format:**
+```json
+{
+  "predicted_label": "n02085620-Chihuahua",
+  "confidence": 0.95,
+  "detection": {
+    "box": {
+      "x": 50.0,
+      "y": 50.0,
+      "width": 400.0,
+      "height": 400.0
+    }
+  },
+  "imageDimensions": {
+    "width": 500,
+    "height": 500
+  }
+}
 ```
 
-### cURL
+### GET /health
+Sağlık kontrolü endpoint'i
 
 ```bash
-curl -X POST https://YOUR-SPACE-URL.hf.space/predict_pet \
-  -F "image=@dog.jpg"
+curl https://alpingo23-petbackend.hf.space/health
 ```
 
-### JavaScript (Fetch)
+## 🔧 React Native Entegrasyonu
 
-```javascript
-const formData = new FormData();
-formData.append('image', fileInput.files[0]);
+App.js dosyanızda zaten doğru endpoint'i kullanıyorsunuz:
 
-const response = await fetch('https://YOUR-SPACE-URL.hf.space/predict_pet', {
-  method: 'POST',
-  body: formData
+```javascript
+const res = await axios.post('https://alpingo23-petbackend.hf.space/predict_pet', formData, {
+  headers: { 'Content-Type': 'multipart/form-data' },
 });
-
-const result = await response.json();
-console.log(result.breed, result.confidence);
 ```
 
-## ℹ️ Model Bilgisi
+## 🐛 Hata Ayıklama
 
-- **Model:** [Pavarissy/ConvNextV2-large-DogBreed](https://huggingface.co/Pavarissy/ConvNextV2-large-DogBreed)
-- **Accuracy:** 91.39% (validation set)
-- **Architecture:** ConvNextV2-large-22k-224
-- **Training:** 50 epochs, Stanford Dogs Dataset
-- **Classes:** 120 dog breeds
+Space çalışmıyorsa:
 
-## 🔧 Performans
+1. **Logs kontrolü**: Space sayfasında "Logs" sekmesini kontrol edin
+2. **Build durumu**: "Building" durumunda mı kontrol edin
+3. **Model yükleme**: İlk açılışta model indirilir, 2-3 dakika sürebilir
+4. **API testi**: `/health` endpoint'ini test edin
 
-- **İlk istek:** 10-15 saniye (model yükleme)
-- **Sonraki istekler:** 2-4 saniye
-- **Hardware:** CPU basic (HF Spaces free tier)
+## 📝 Notlar
 
-## 📄 License
+- Model ilk yüklendiğinde indirme yapacağı için 2-3 dakika sürebilir
+- CORS tüm kaynaklardan gelen isteklere açık (production'da düzeltilmeli)
+- Detection box simülasyondur, gerçek nesne tespiti yapmaz
+- Model 120+ köpek ırkını tanıyabilir
 
-MIT
+## 🔗 Bağlantılar
 
+- Model: https://huggingface.co/Pavarissy/ConvNextV2-large-DogBreed
+- Space URL: https://alpingo23-petbackend.hf.space
+- Docs: https://alpingo23-petbackend.hf.space/docs (otomatik FastAPI docs)

app.py

@@ -1,106 +1,126 @@
-"""
-Clean Pet Backend for Hugging Face Spaces
-Using ConvNextV2-large-DogBreed model
-"""
-
-from flask import Flask, request, jsonify
-from flask_cors import CORS
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
 from PIL import Image
 import io
-import os
-
-# Set cache directories FIRST
-os.environ['HF_HOME'] = '/tmp/.cache'
-os.environ['TRANSFORMERS_CACHE'] = '/tmp/.cache'
-os.environ['TORCH_HOME'] = '/tmp/.cache'
-
-app = Flask(__name__)
-CORS(app)
-
-# Global model variables
-model = None
-processor = None
-
-def load_model():
-    """Load model on first request"""
-    global model, processor
-    
-    if model is not None:
-        return
-    
-    print("🔄 Loading ConvNextV2-large-DogBreed model...")
-    
-    from transformers import AutoImageProcessor, AutoModelForImageClassification
-    import torch
-    
-    model_name = "Pavarissy/ConvNextV2-large-DogBreed"
-    
-    processor = AutoImageProcessor.from_pretrained(model_name)
-    model = AutoModelForImageClassification.from_pretrained(model_name)
-    
-    device = "cuda" if torch.cuda.is_available() else "cpu"
-    model = model.to(device)
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+import numpy as np
+
+app = FastAPI()
+
+# CORS ayarları - Tüm kaynaklardan gelen isteklere izin ver
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Model ve processor'ı yükle
+MODEL_NAME = "Pavarissy/ConvNextV2-large-DogBreed"
+print(f"🔄 Loading model: {MODEL_NAME}")
+
+try:
+    processor = AutoImageProcessor.from_pretrained(MODEL_NAME)
+    model = AutoModelForImageClassification.from_pretrained(MODEL_NAME)
     model.eval()
-    
-    print(f"✅ Model loaded on {device}")
-
-@app.route('/', methods=['GET'])
-def health():
-    return jsonify({
-        'status': 'healthy',
-        'model': 'ConvNextV2-large-DogBreed',
-        'accuracy': '91.39%'
-    })
-
-@app.route('/predict_pet', methods=['POST'])
-def predict_pet():
+    print("✅ Model loaded successfully!")
+except Exception as e:
+    print(f"❌ Error loading model: {e}")
+    raise e
+
+@app.get("/")
+async def root():
+    """Ana endpoint - API durumunu gösterir"""
+    return {
+        "message": "Dog Breed Classification API",
+        "model": MODEL_NAME,
+        "status": "ready",
+        "endpoints": {
+            "predict": "/predict_pet (POST)",
+            "health": "/health (GET)"
+        }
+    }
+
+@app.post("/predict_pet")
+async def predict_pet(image: UploadFile = File(...)):
+    """
+    Pet (köpek ırkı) tahmini endpoint'i
+
+    Expected response format:
+    {
+        "predicted_label": "n02085620-Chihuahua",
+        "confidence": 0.95,
+        "detection": {
+            "box": {"x": 50, "y": 50, "width": 400, "height": 400}
+        }
+    }
+    """
     try:
-        # Load model if needed
-        load_model()
-        
-        # Get image
-        if 'image' not in request.files:
-            return jsonify({'error': 'No image provided'}), 400
-        
-        file = request.files['image']
-        image = Image.open(io.BytesIO(file.read())).convert('RGB')
-        
-        # Process and predict
-        import torch
-        inputs = processor(image, return_tensors="pt")
-        
-        device = next(model.parameters()).device
-        inputs = {k: v.to(device) for k, v in inputs.items()}
-        
+        # Resmi oku ve RGB'ye çevir
+        image_bytes = await image.read()
+        img = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+
+        # Orijinal görüntü boyutları
+        width, height = img.size
+        print(f"📸 Image received: {width}x{height}")
+
+        # Model için preprocessing
+        inputs = processor(images=img, return_tensors="pt")
+
+        # Tahmin yap
         with torch.no_grad():
             outputs = model(**inputs)
             logits = outputs.logits
-        
-        # Get top prediction
-        probs = torch.nn.functional.softmax(logits, dim=-1)[0]
-        top_prob, top_idx = torch.max(probs, dim=0)
-        
-        predicted_breed = model.config.id2label[top_idx.item()]
-        confidence = float(top_prob.item())
-        
-        print(f"✅ Predicted: {predicted_breed} ({confidence:.2%})")
-        
-        # Return in format expected by frontend
-        return jsonify({
-            'predicted_label': predicted_breed,
-            'breed': predicted_breed,
-            'confidence': confidence,
-            'detection': {'box': {'x': 0, 'y': 0, 'width': 0, 'height': 0}},
-            'gender': 'Unknown'
-        })
-        
+
+        # Softmax ile olasılıkları hesapla
+        probabilities = torch.nn.functional.softmax(logits, dim=-1)
+        confidence, predicted_idx = torch.max(probabilities, dim=-1)
+
+        # Tahmin edilen sınıfı al
+        predicted_label = model.config.id2label[predicted_idx.item()]
+        confidence_score = confidence.item()
+
+        # Basit bir detection box oluştur (görüntünün %80'i merkeze yerleştirilmiş)
+        box_margin = 0.1
+        detection_box = {
+            "x": float(width * box_margin),
+            "y": float(height * box_margin),
+            "width": float(width * (1 - 2 * box_margin)),
+            "height": float(height * (1 - 2 * box_margin))
+        }
+
+        # Yanıt hazırla (React Native app'in beklediği formatta)
+        response = {
+            "predicted_label": predicted_label,
+            "confidence": float(confidence_score),
+            "detection": {
+                "box": detection_box
+            },
+            "imageDimensions": {
+                "width": width,
+                "height": height
+            }
+        }
+
+        print(f"✅ Prediction: {predicted_label} (confidence: {confidence_score:.4f})")
+        return response
+
     except Exception as e:
-        print(f"❌ Error: {str(e)}")
-        import traceback
-        traceback.print_exc()
-        return jsonify({'error': str(e)}), 500
-
-if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    print(f"🚀 Starting server on port {port}")
-    app.run(host='0.0.0.0', port=port, debug=False)
+        print(f"❌ Error during prediction: {str(e)}")
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")
+
+@app.get("/health")
+async def health_check():
+    """Sağlık kontrolü endpoint'i"""
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None,
+        "model_name": MODEL_NAME
+    }
+
+# Hugging Face Space'te uvicorn otomatik çalışır
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

requirements.txt

@@ -1,7 +1,8 @@
-flask==3.0.0
-flask-cors==4.0.0
-transformers==4.35.0
-torch==2.1.0
-torchvision==0.16.0
-pillow==10.1.0
-accelerate==0.24.0
+fastapi
+uvicorn[standard]
+python-multipart
+pillow
+torch
+torchvision
+transformers
+numpy