Upload folder using huggingface_hub

.github/workflows/update_space.yml

@@ -0,0 +1,28 @@
+name: Run Python script
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - name: Checkout
+      uses: actions/checkout@v2
+
+    - name: Set up Python
+      uses: actions/setup-python@v2
+      with:
+        python-version: '3.9'
+
+    - name: Install Gradio
+      run: python -m pip install gradio
+
+    - name: Log in to Hugging Face
+      run: python -c 'import huggingface_hub; huggingface_hub.login(token="${{ secrets.hf_token }}")'
+
+    - name: Deploy to Spaces
+      run: gradio deploy

app.py

@@ -18,28 +18,48 @@ class PhotoUpscaler:
         self.load_default_model()
     
     def load_default_model(self):
-        """Load default upscaling model"""
-        try:
-            # Using a Real-ESRGAN style model from Hugging Face
-            self.current_model = "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr"
-            self.upscaler = pipeline(
-                "image-to-image",
-                model=self.current_model,
-                device=0 if self.device == "cuda" else -1
-            )
-            return f"✅ Model načten: {self.current_model}"
-        except Exception as e:
-            # Fallback to a simpler approach
-            self.current_model = "microsoft/swin2SR-compressed-sr-x2-48"
+        """Load default upscaling model with Real-ESRGAN priority"""
+        # Priority list of models to try
+        priority_models = [
+            "ai-forever/Real-ESRGAN",
+            "sberbank-ai/Real-ESRGAN", 
+            "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
+            "microsoft/swin2SR-compressed-sr-x2-48"
+        ]
+        
+        for model_name in priority_models:
             try:
-                self.upscaler = pipeline(
-                    "image-to-image", 
-                    model=self.current_model,
-                    device=0 if self.device == "cuda" else -1
-                )
-                return f"✅ Fallback model načten: {self.current_model}"
-            except:
-                return f"❌ Chyba při načítání modelů: {str(e)}"
+                self.current_model = model_name
+                if "Real-ESRGAN" in model_name:
+                    # Special handling for Real-ESRGAN models
+                    try:
+                        from diffusers import StableDiffusionUpscalePipeline
+                        self.upscaler = StableDiffusionUpscalePipeline.from_pretrained(
+                            model_name, 
+                            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                        ).to(self.device)
+                        return f"✅ Real-ESRGAN model načten: {self.current_model}"
+                    except:
+                        # Fallback to regular pipeline
+                        self.upscaler = pipeline(
+                            "image-to-image",
+                            model=model_name,
+                            device=0 if self.device == "cuda" else -1
+                        )
+                        return f"✅ Model načten: {self.current_model}"
+                else:
+                    # Regular Swin2SR models
+                    self.upscaler = pipeline(
+                        "image-to-image",
+                        model=model_name,
+                        device=0 if self.device == "cuda" else -1
+                    )
+                    return f"✅ Model načten: {self.current_model}"
+            except Exception as e:
+                print(f"Nepodařilo se načíst {model_name}: {e}")
+                continue
+        
+        return f"❌ Nepodařilo se načíst žádný model"
     
     def upscale_image(self, image, scale_factor=2, model_choice="default"):
         """Upscale image using selected model"""
@@ -62,18 +82,50 @@ class PhotoUpscaler:
             if model_choice != "default" and model_choice != self.current_model:
                 self.load_model(model_choice)
             
-            # Perform upscaling
+            # Perform upscaling based on model type
             if self.upscaler:
-                # For pipeline-based upscaling
-                upscaled = self.upscaler(image)
-                if isinstance(upscaled, list):
-                    upscaled = upscaled[0]
-                if hasattr(upscaled, 'images'):
-                    upscaled = upscaled.images[0]
-                elif isinstance(upscaled, dict) and 'image' in upscaled:
-                    upscaled = upscaled['image']
-                
-                return upscaled, f"✅ Obrázek zvětšen pomocí {self.current_model}"
+                try:
+                    if "Real-ESRGAN" in self.current_model:
+                        # Special handling for Real-ESRGAN models
+                        if hasattr(self.upscaler, '__call__'):
+                            # Diffusers pipeline
+                            prompt = "high quality, detailed, sharp"
+                            upscaled = self.upscaler(
+                                prompt=prompt, 
+                                image=image,
+                                num_inference_steps=20,
+                                guidance_scale=0
+                            ).images[0]
+                        else:
+                            # Regular pipeline fallback
+                            upscaled = self.upscaler(image)
+                    elif "stable-diffusion" in self.current_model.lower():
+                        # Stable Diffusion upscaler
+                        from diffusers import StableDiffusionUpscalePipeline
+                        prompt = "high quality, detailed, sharp, realistic"
+                        upscaled = self.upscaler(
+                            prompt=prompt,
+                            image=image,
+                            num_inference_steps=20
+                        ).images[0]
+                    else:
+                        # Standard Swin2SR and other models
+                        upscaled = self.upscaler(image)
+                        if isinstance(upscaled, list):
+                            upscaled = upscaled[0]
+                        if hasattr(upscaled, 'images'):
+                            upscaled = upscaled.images[0]
+                        elif isinstance(upscaled, dict) and 'image' in upscaled:
+                            upscaled = upscaled['image']
+                    
+                    return upscaled, f"✅ Obrázek zvětšen pomocí {MODEL_DESCRIPTIONS.get(self.current_model, self.current_model)}"
+                    
+                except Exception as model_error:
+                    print(f"Model error: {model_error}")
+                    # Fallback to simple upscaling
+                    new_size = tuple(int(dim * scale_factor) for dim in image.size)
+                    upscaled = image.resize(new_size, Image.Resampling.LANCZOS)
+                    return upscaled, f"✅ Obrázek zvětšen pomocí klasického algoritmu (model selhání)"
             else:
                 # Simple fallback upscaling
                 new_size = tuple(int(dim * scale_factor) for dim in image.size)
@@ -84,17 +136,57 @@ class PhotoUpscaler:
             return None, f"❌ Chyba při zpracování: {str(e)}"
     
     def load_model(self, model_name):
-        """Load specific model"""
+        """Load specific model with enhanced support for different model types"""
         try:
             self.current_model = model_name
-            self.upscaler = pipeline(
-                "image-to-image",
-                model=model_name,
-                device=0 if self.device == "cuda" else -1
-            )
-            return f"✅ Model změněn na: {model_name}"
+            
+            if "Real-ESRGAN" in model_name:
+                # Try Real-ESRGAN specific loading
+                try:
+                    from diffusers import StableDiffusionUpscalePipeline
+                    self.upscaler = StableDiffusionUpscalePipeline.from_pretrained(
+                        model_name,
+                        torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                    ).to(self.device)
+                    return f"✅ Real-ESRGAN model načten: {MODEL_DESCRIPTIONS.get(model_name, model_name)}"
+                except:
+                    # Fallback to regular pipeline
+                    self.upscaler = pipeline(
+                        "image-to-image",
+                        model=model_name,
+                        device=0 if self.device == "cuda" else -1
+                    )
+                    return f"✅ Model načten (fallback): {MODEL_DESCRIPTIONS.get(model_name, model_name)}"
+            
+            elif "stable-diffusion" in model_name.lower():
+                # Stable Diffusion upscaler
+                from diffusers import StableDiffusionUpscalePipeline
+                self.upscaler = StableDiffusionUpscalePipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                ).to(self.device)
+                return f"✅ SD Upscaler načten: {MODEL_DESCRIPTIONS.get(model_name, model_name)}"
+            
+            elif "ldm" in model_name.lower():
+                # LDM models
+                from diffusers import LDMSuperResolutionPipeline
+                self.upscaler = LDMSuperResolutionPipeline.from_pretrained(
+                    model_name,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32
+                ).to(self.device)
+                return f"✅ LDM model načten: {MODEL_DESCRIPTIONS.get(model_name, model_name)}"
+            
+            else:
+                # Standard pipeline for Swin2SR and similar models
+                self.upscaler = pipeline(
+                    "image-to-image",
+                    model=model_name,
+                    device=0 if self.device == "cuda" else -1
+                )
+                return f"✅ Model načten: {MODEL_DESCRIPTIONS.get(model_name, model_name)}"
+                
         except Exception as e:
-            return f"❌ Chyba při načítání modelu {model_name}: {str(e)}"
+            return f"❌ Chyba při načítání modelu {MODEL_DESCRIPTIONS.get(model_name, model_name)}: {str(e)}"
 
 # Initialize upscaler
 upscaler = PhotoUpscaler()
@@ -102,13 +194,50 @@ upscaler = PhotoUpscaler()
 # Available models for upscaling
 UPSCALING_MODELS = [
     "default",
-    "microsoft/swin2SR-compressed-sr-x2-48",
-    "microsoft/swin2SR-compressed-sr-x4-48", 
+    # Real-ESRGAN models (nejlepší pro realistické fotografie)
+    "ai-forever/Real-ESRGAN",
+    "sberbank-ai/Real-ESRGAN",
+    "philz1337x/clarity-upscaler",
+    
+    # BSRGAN models (vynikající pro reálné obrázky)
     "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
+    "caidas/swin2SR-realworld-sr-x2-64-bsrgan-psnr",
+    
+    # SwinIR models (state-of-the-art)
+    "caidas/swinIR-M-real-sr-x4-64-bsrgan-psnr",
+    "caidas/swinIR-L-real-sr-x4-64-bsrgan-psnr",
+    
+    # Microsoft Swin2SR (optimalizované)
+    "microsoft/swin2SR-compressed-sr-x2-48",
+    "microsoft/swin2SR-compressed-sr-x4-48",
     "microsoft/swin2SR-classical-sr-x2-64",
-    "microsoft/swin2SR-classical-sr-x4-64"
+    "microsoft/swin2SR-classical-sr-x4-64",
+    "microsoft/swin2SR-realworld-sr-x4-64-bsrgan-psnr",
+    
+    # Další pokročilé modely
+    "Kolors/Kolors-IP-Adapter-FaceID-Plus",
+    "stabilityai/stable-diffusion-x4-upscaler",
+    "CompVis/ldm-super-resolution-4x-openimages"
 ]
 
+# Model descriptions for better user experience
+MODEL_DESCRIPTIONS = {
+    "default": "🎯 Výchozí model - rychlý a spolehlivý",
+    "ai-forever/Real-ESRGAN": "🏆 Real-ESRGAN - nejlepší pro fotografie",
+    "sberbank-ai/Real-ESRGAN": "⭐ Real-ESRGAN Sberbank - vylepšená verze",
+    "philz1337x/clarity-upscaler": "✨ Clarity Upscaler - ultra ostrý",
+    "caidas/swin2SR-realworld-sr-x4-64-bsrgan-psnr": "🌟 BSRGAN 4x - premium kvalita",
+    "caidas/swin2SR-realworld-sr-x2-64-bsrgan-psnr": "🌟 BSRGAN 2x - rychlejší",
+    "caidas/swinIR-M-real-sr-x4-64-bsrgan-psnr": "🚀 SwinIR Medium - vyváženost",
+    "caidas/swinIR-L-real-sr-x4-64-bsrgan-psnr": "🔥 SwinIR Large - maximální kvalita",
+    "microsoft/swin2SR-compressed-sr-x2-48": "⚡ Komprimovaný 2x - rychlý",
+    "microsoft/swin2SR-compressed-sr-x4-48": "⚡ Komprimovaný 4x - rychlý",
+    "microsoft/swin2SR-classical-sr-x2-64": "🎨 Klasický 2x - digitální obrázky",
+    "microsoft/swin2SR-classical-sr-x4-64": "🎨 Klasický 4x - digitální obrázky",
+    "stabilityai/stable-diffusion-x4-upscaler": "🎭 SD Upscaler - kreativní vylepšení",
+    "CompVis/ldm-super-resolution-4x-openimages": "🧠 LDM - generativní upscaling"
+}
+
 def process_upscaling(image, scale_factor, model_choice, hf_token):
     """Main processing function"""
     # Login to HuggingFace if token provided
@@ -175,10 +304,10 @@ with gr.Blocks(
             )
             
             model_choice = gr.Dropdown(
-                choices=UPSCALING_MODELS,
+                choices=[(MODEL_DESCRIPTIONS.get(model, model), model) for model in UPSCALING_MODELS],
                 value="default",
                 label="Vyberte model",
-                info="Různé modely pro různé typy obrázků"
+                info="Různé modely pro různé typy obrázků - Real-ESRGAN nejlepší pro fotografie"
             )
             
             hf_token = gr.Textbox(
@@ -221,14 +350,40 @@ with gr.Blocks(
         outputs=status_text
     )
     
-    # Examples
-    gr.Markdown("### 📋 Tipy pro použití")
+    # Examples and tips
+    gr.Markdown("### 📋 Tipy pro nejlepší výsledky")
+    
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("""
+            **🏆 Nejlepší modely pro fotografie:**
+            - **Real-ESRGAN**: Nejkvalitnější pro reálné fotky
+            - **BSRGAN**: Vynikající detail a ostrost
+            - **SwinIR Large**: Maximální kvalita, pomalejší
+            - **Clarity Upscaler**: Ultra ostrý výsledek
+            """)
+        
+        with gr.Column():
+            gr.Markdown("""
+            **⚡ Rychlé modely:**
+            - **Komprimované modely**: Rychlé zpracování
+            - **2x modely**: Rychlejší než 4x verze
+            - **Classical modely**: Pro digitální obrázky
+            """)
+    
     gr.Markdown("""
-    - **Nejlepší výsledky**: Používejte obrázky s rozlišením 256x256 až 512x512 pixelů
-    - **Modely**: Různé modely jsou optimalizované pro různé typy obrázků
-    - **Real-world modely**: Nejlepší pro fotografie z reálného světa
-    - **Classical modely**: Vhodné pro umělé nebo digitální obrázky
-    - **HF Token**: Zadejte pro přístup k nejnovějším modelům
+    ### 💡 Doporučení podle typu obrázku:
+    - **Portréty**: Real-ESRGAN nebo SwinIR Large
+    - **Krajiny**: BSRGAN nebo Clarity Upscaler  
+    - **Staré fotky**: Real-ESRGAN s noise reduction
+    - **Digitální art**: Classical nebo Stable Diffusion Upscaler
+    - **Dokumenty**: SwinIR Medium pro čitelnost
+    
+    ### ⚙️ Optimalizace výkonu:
+    - **GPU**: Automaticky detekováno pro rychlejší zpracování
+    - **Velikost**: 256-512px pro nejlepší poměr rychlost/kvalita
+    - **Formát**: PNG zachovává nejvyšší kvalitu
+    - **HF Token**: Pro přístup k nejnovějším modelům
     """)
 
 if __name__ == "__main__":