Upload 2 files

app.py

@@ -0,0 +1,543 @@
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+import gradio as gr
+import time
+import spaces
+import timm
+from torchvision.ops import nms, box_iou
+import torch.nn.functional as F
+from torchvision import transforms
+from PIL import Image, ImageDraw, ImageFont, ImageFilter
+from breed_health_info import breed_health_info
+from breed_noise_info import breed_noise_info
+from dog_database import get_dog_description
+from scoring_calculation_system import UserPreferences, calculate_compatibility_score
+from recommendation_html_format import format_recommendation_html, get_breed_recommendations
+from history_manager import UserHistoryManager
+from search_history import create_history_tab, create_history_component
+from styles import get_css_styles
+from breed_detection import create_detection_tab
+from breed_comparison import create_comparison_tab
+from breed_recommendation import create_recommendation_tab
+from breed_visualization import create_visualization_tab
+from style_transfer import DogStyleTransfer, create_style_transfer_tab
+from html_templates import (
+    format_description_html,
+    format_single_dog_result,
+    format_multiple_breeds_result,
+    format_unknown_breed_message,
+    format_not_dog_message,
+    format_hint_html,
+    format_multi_dog_container,
+    format_breed_details_html,
+    get_color_scheme,
+    get_akc_breeds_link
+)
+from model_architecture import BaseModel, dog_breeds
+from urllib.parse import quote
+from ultralytics import YOLO
+import asyncio
+import traceback
+
+history_manager = UserHistoryManager()
+
+class ModelManager:
+    """
+    Singleton class for managing model instances and device allocation
+    specifically designed for Hugging Face Spaces deployment.
+    """
+    _instance = None
+    _initialized = False
+    _yolo_model = None
+    _breed_model = None
+    _device = None
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def __init__(self):
+        if not ModelManager._initialized:
+            self._device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+            ModelManager._initialized = True
+
+    @property
+    def device(self):
+        if self._device is None:
+            self._device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        return self._device
+
+    @property
+    def yolo_model(self):
+        if self._yolo_model is None:
+            self._yolo_model = YOLO('yolov8x.pt')
+        return self._yolo_model
+
+    @property
+    def breed_model(self):
+        if self._breed_model is None:
+            self._breed_model = BaseModel(
+                num_classes=len(dog_breeds),
+                device=self.device
+            ).to(self.device)
+
+            checkpoint = torch.load(
+                'ConvNextV2Base_best_model.pth',
+                map_location=self.device
+            )
+            self._breed_model.load_state_dict(checkpoint['base_model'], strict=False)
+            self._breed_model.eval()
+        return self._breed_model
+
+# Initialize model manager
+model_manager = ModelManager()
+
+def preprocess_image(image):
+    """Preprocesses images for model input"""
+    if isinstance(image, np.ndarray):
+        image = Image.fromarray(image)
+
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+    ])
+
+    return transform(image).unsqueeze(0)
+
+@spaces.GPU
+def predict_single_dog(image):
+    """Predicts dog breed for a single image"""
+    image_tensor = preprocess_image(image).to(model_manager.device)
+
+    with torch.no_grad():
+        logits = model_manager.breed_model(image_tensor)[0]
+        probs = F.softmax(logits, dim=1)
+
+        top5_prob, top5_idx = torch.topk(probs, k=5)
+        breeds = [dog_breeds[idx.item()] for idx in top5_idx[0]]
+        probabilities = [prob.item() for prob in top5_prob[0]]
+
+        sum_probs = sum(probabilities[:3])
+        relative_probs = [f"{(prob/sum_probs * 100):.2f}%" for prob in probabilities[:3]]
+
+        return probabilities[0], breeds[:3], relative_probs
+
+def enhanced_preprocess(image, is_standing=False, has_overlap=False):
+    """
+    Enhanced image preprocessing function with special handling for different poses
+    and overlapping cases.
+    """
+    target_size = 224
+    w, h = image.size
+
+    if is_standing:
+        if h > w * 1.5:
+            new_h = target_size
+            new_w = min(target_size, int(w * (target_size / h)))
+            new_w = max(new_w, int(target_size * 0.6))
+    elif has_overlap:
+        scale = min(target_size/w, target_size/h) * 0.95
+        new_w = int(w * scale)
+        new_h = int(h * scale)
+    else:
+        scale = min(target_size/w, target_size/h)
+        new_w = int(w * scale)
+        new_h = int(h * scale)
+
+    resized = image.resize((new_w, new_h), Image.Resampling.LANCZOS)
+    final_image = Image.new('RGB', (target_size, target_size), (240, 240, 240))
+    paste_x = (target_size - new_w) // 2
+    paste_y = (target_size - new_h) // 2
+    final_image.paste(resized, (paste_x, paste_y))
+
+    return final_image
+
+@spaces.GPU
+def detect_multiple_dogs(image, conf_threshold=0.3, iou_threshold=0.3):
+    """
+    Enhanced multiple dog detection with improved bounding box handling and
+    intelligent boundary adjustments.
+    """
+    results = model_manager.yolo_model(image, conf=conf_threshold, iou=iou_threshold)[0]
+    img_width, img_height = image.size
+    detected_boxes = []
+
+    # Phase 1: Initial detection and processing
+    for box in results.boxes:
+        if box.cls.item() == 16:  # Dog class
+            xyxy = box.xyxy[0].tolist()
+            confidence = box.conf.item()
+            x1, y1, x2, y2 = map(int, xyxy)
+            w = x2 - x1
+            h = y2 - y1
+
+            detected_boxes.append({
+                'coords': [x1, y1, x2, y2],
+                'width': w,
+                'height': h,
+                'center_x': (x1 + x2) / 2,
+                'center_y': (y1 + y2) / 2,
+                'area': w * h,
+                'confidence': confidence,
+                'aspect_ratio': w / h if h != 0 else 1
+            })
+
+    if not detected_boxes:
+        return [(image, 1.0, [0, 0, img_width, img_height], False)]
+
+    # Phase 2: Analysis of detection relationships
+    avg_height = sum(box['height'] for box in detected_boxes) / len(detected_boxes)
+    avg_width = sum(box['width'] for box in detected_boxes) / len(detected_boxes)
+    avg_area = sum(box['area'] for box in detected_boxes) / len(detected_boxes)
+
+    def calculate_iou(box1, box2):
+        x1 = max(box1['coords'][0], box2['coords'][0])
+        y1 = max(box1['coords'][1], box2['coords'][1])
+        x2 = min(box1['coords'][2], box2['coords'][2])
+        y2 = min(box1['coords'][3], box2['coords'][3])
+
+        if x2 <= x1 or y2 <= y1:
+            return 0.0
+
+        intersection = (x2 - x1) * (y2 - y1)
+        area1 = box1['area']
+        area2 = box2['area']
+        return intersection / (area1 + area2 - intersection)
+
+    # Phase 3: Processing each detection
+    processed_boxes = []
+    overlap_threshold = 0.2
+
+    for i, box_info in enumerate(detected_boxes):
+        x1, y1, x2, y2 = box_info['coords']
+        w = box_info['width']
+        h = box_info['height']
+        center_x = box_info['center_x']
+        center_y = box_info['center_y']
+
+        # Check for overlaps
+        has_overlap = False
+        for j, other_box in enumerate(detected_boxes):
+            if i != j and calculate_iou(box_info, other_box) > overlap_threshold:
+                has_overlap = True
+                break
+
+        # Adjust expansion strategy
+        base_expansion = 0.03
+        max_expansion = 0.05
+
+        is_standing = h > 1.5 * w
+        is_sitting = 0.8 <= h/w <= 1.2
+        is_abnormal_size = (h * w) > (avg_area * 1.5) or (h * w) < (avg_area * 0.5)
+
+        if has_overlap:
+            h_expansion = w_expansion = base_expansion * 0.8
+        else:
+            if is_standing:
+                h_expansion = min(base_expansion * 1.2, max_expansion)
+                w_expansion = base_expansion
+            elif is_sitting:
+                h_expansion = w_expansion = base_expansion
+            else:
+                h_expansion = w_expansion = base_expansion * 0.9
+
+        # Position compensation
+        if center_x < img_width * 0.2 or center_x > img_width * 0.8:
+            w_expansion *= 0.9
+
+        if is_abnormal_size:
+            h_expansion *= 0.8
+            w_expansion *= 0.8
+
+        # Calculate final bounding box
+        expansion_w = w * w_expansion
+        expansion_h = h * h_expansion
+
+        new_x1 = max(0, center_x - (w + expansion_w)/2)
+        new_y1 = max(0, center_y - (h + expansion_h)/2)
+        new_x2 = min(img_width, center_x + (w + expansion_w)/2)
+        new_y2 = min(img_height, center_y + (h + expansion_h)/2)
+
+        # Crop and process image
+        cropped_image = image.crop((int(new_x1), int(new_y1),
+                                  int(new_x2), int(new_y2)))
+
+        processed_image = enhanced_preprocess(
+            cropped_image,
+            is_standing=is_standing,
+            has_overlap=has_overlap
+        )
+
+        processed_boxes.append((
+            processed_image,
+            box_info['confidence'],
+            [new_x1, new_y1, new_x2, new_y2],
+            True
+        ))
+
+    return processed_boxes
+
+@spaces.GPU
+def predict(image):
+    """
+    Main prediction function that handles both single and multiple dog detection.
+    Args:
+        image: PIL Image or numpy array
+    Returns:
+        tuple: (html_output, annotated_image, initial_state)
+    """
+    if image is None:
+        return format_hint_html("Please upload an image to start."), None, None
+
+    try:
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+
+        # 檢測圖片中的物體
+        dogs = detect_multiple_dogs(image)
+        color_scheme = get_color_scheme(len(dogs) == 1)
+
+        # 準備標註
+        annotated_image = image.copy()
+        draw = ImageDraw.Draw(annotated_image)
+
+        try:
+            font = ImageFont.truetype("arial.ttf", 24)
+        except:
+            font = ImageFont.load_default()
+
+        dogs_info = ""
+
+        # 處理每個檢測到的物體
+        for i, (cropped_image, detection_confidence, box, is_dog) in enumerate(dogs):
+            print(f"Predict processing - Object {i+1}:")
+            print(f"    Is dog: {is_dog}")
+            print(f"    Detection confidence: {detection_confidence:.4f}")
+
+            # 如果是狗且進行品種預測，在這裡也加入打印語句
+            if is_dog:
+                top1_prob, topk_breeds, relative_probs = predict_single_dog(cropped_image)
+                print(f"    Breed prediction - Top probability: {top1_prob:.4f}")
+                print(f"    Top breeds: {topk_breeds[:3]}")
+            color = color_scheme if len(dogs) == 1 else color_scheme[i % len(color_scheme)]
+
+            # 繪製框和標籤
+            draw.rectangle(box, outline=color, width=4)
+            label = f"Dog {i+1}" if is_dog else f"Object {i+1}"
+            label_bbox = draw.textbbox((0, 0), label, font=font)
+            label_width = label_bbox[2] - label_bbox[0]
+            label_height = label_bbox[3] - label_bbox[1]
+
+            # 繪製標籤背景和文字
+            label_x = box[0] + 5
+            label_y = box[1] + 5
+            draw.rectangle(
+                [label_x - 2, label_y - 2, label_x + label_width + 4, label_y + label_height + 4],
+                fill='white',
+                outline=color,
+                width=2
+            )
+            draw.text((label_x, label_y), label, fill=color, font=font)
+
+            try:
+                # 首先檢查是否為狗
+                if not is_dog:
+                    dogs_info += format_not_dog_message(color, i+1)
+                    continue
+
+                # 如果是狗，進行品種預測
+                top1_prob, topk_breeds, relative_probs = predict_single_dog(cropped_image)
+                combined_confidence = detection_confidence * top1_prob
+
+                # 根據信心度決定輸出格式
+                if combined_confidence < 0.15:
+                    dogs_info += format_unknown_breed_message(color, i+1)
+                elif top1_prob >= 0.4:
+                    breed = topk_breeds[0]
+                    description = get_dog_description(breed)
+                    if description is None:
+                        description = {
+                            "Name": breed,
+                            "Size": "Unknown",
+                            "Exercise Needs": "Unknown",
+                            "Grooming Needs": "Unknown",
+                            "Care Level": "Unknown",
+                            "Good with Children": "Unknown",
+                            "Description": f"Identified as {breed.replace('_', ' ')}"
+                        }
+                    dogs_info += format_single_dog_result(breed, description, color)
+                else:
+                    dogs_info += format_multiple_breeds_result(
+                        topk_breeds,
+                        relative_probs,
+                        color,
+                        i+1,
+                        lambda breed: get_dog_description(breed) or {
+                            "Name": breed,
+                            "Size": "Unknown",
+                            "Exercise Needs": "Unknown",
+                            "Grooming Needs": "Unknown",
+                            "Care Level": "Unknown",
+                            "Good with Children": "Unknown",
+                            "Description": f"Identified as {breed.replace('_', ' ')}"
+                        }
+                    )
+            except Exception as e:
+                print(f"Error formatting results for dog {i+1}: {str(e)}")
+                dogs_info += format_unknown_breed_message(color, i+1)
+
+        # 包裝最終的HTML輸出
+        html_output = format_multi_dog_container(dogs_info)
+
+        # 準備初始狀態
+        initial_state = {
+            "dogs_info": dogs_info,
+            "image": annotated_image,
+            "is_multi_dog": len(dogs) > 1,
+            "html_output": html_output
+        }
+
+        return html_output, annotated_image, initial_state
+
+    except Exception as e:
+        error_msg = f"An error occurred: {str(e)}\n\nTraceback:\n{traceback.format_exc()}"
+        print(error_msg)
+        return format_hint_html(error_msg), None, None
+
+
+def show_details_html(choice, previous_output, initial_state):
+    """
+    Generate detailed HTML view for a selected breed.
+
+    Args:
+        choice: str, Selected breed option
+        previous_output: str, Previous HTML output
+        initial_state: dict, Current state information
+
+    Returns:
+        tuple: (html_output, gradio_update, updated_state)
+    """
+    if not choice:
+        return previous_output, gr.update(visible=True), initial_state
+
+    try:
+        breed = choice.split("More about ")[-1]
+        description = get_dog_description(breed)
+        html_output = format_breed_details_html(description, breed)
+
+        # Update state
+        initial_state["current_description"] = html_output
+        initial_state["original_buttons"] = initial_state.get("buttons", [])
+
+        return html_output, gr.update(visible=True), initial_state
+
+    except Exception as e:
+        error_msg = f"An error occurred while showing details: {e}"
+        print(error_msg)
+        return format_hint_html(error_msg), gr.update(visible=True), initial_state
+
+def main():
+    with gr.Blocks(css=get_css_styles()) as iface:
+        # Header HTML
+
+        gr.HTML("""
+        <header style='text-align: center; padding: 20px; margin-bottom: 20px;'>
+            <h1 style='font-size: 2.5em; margin-bottom: 10px; color: #2D3748;'>
+                🐾 PawMatch AI
+            </h1>
+            <h2 style='font-size: 1.2em; font-weight: normal; color: #4A5568; margin-top: 5px;'>
+                Your Smart Dog Breed Guide
+            </h2>
+            <div style='width: 50px; height: 3px; background: linear-gradient(90deg, #4299e1, #48bb78); margin: 15px auto;'></div>
+            <p style='color: #718096; font-size: 0.9em;'>
+                Powered by AI • Breed Recognition • Smart Matching • Companion Guide
+            </p>
+        </header>
+        """)
+
+        # 先創建歷史組件實例（但不創建標籤頁）
+        history_component = create_history_component()
+
+        # Initialize style transfor
+        dog_style_transfer = DogStyleTransfer()
+
+        with gr.Tabs():
+            # 1. breed detection
+            example_images = [
+                'Border_Collie.jpg',
+                'Golden_Retriever.jpeg',
+                'Saint_Bernard.jpeg',
+                'Samoyed.jpeg',
+                'French_Bulldog.jpeg'
+            ]
+            detection_components = create_detection_tab(predict, example_images)
+
+            # 2. breed comparison
+            comparison_components = create_comparison_tab(
+                dog_breeds=dog_breeds,
+                get_dog_description=get_dog_description,
+                breed_health_info=breed_health_info,
+                breed_noise_info=breed_noise_info
+            )
+
+            # 3. breed recommendation
+            recommendation_components = create_recommendation_tab(
+                UserPreferences=UserPreferences,
+                get_breed_recommendations=get_breed_recommendations,
+                format_recommendation_html=format_recommendation_html,
+                history_component=history_component
+            )
+
+            # 4. Visualization Analysis
+            with gr.Tab("Visualization Analysis"):
+                create_visualization_tab(
+                    dog_breeds=dog_breeds,
+                    get_dog_description=get_dog_description,
+                    calculate_compatibility_score=calculate_compatibility_score,
+                    UserPreferences=UserPreferences
+                )
+
+            # 5. Style Transfer tab
+            with gr.Tab("Style Transfer"):
+                style_transfer_components = create_style_transfer_tab(dog_style_transfer)
+
+
+            # 6. History Search
+            create_history_tab(history_component)
+
+        # Footer
+        gr.HTML('''
+            <div style="
+                display: flex;
+                align-items: center;
+                justify-content: center;
+                gap: 20px;
+                padding: 20px 0;
+            ">
+                <p style="
+                    font-family: 'Arial', sans-serif;
+                    font-size: 14px;
+                    font-weight: 500;
+                    letter-spacing: 2px;
+                    background: linear-gradient(90deg, #555, #007ACC);
+                    -webkit-background-clip: text;
+                    -webkit-text-fill-color: transparent;
+                    margin: 0;
+                    text-transform: uppercase;
+                    display: inline-block;
+                ">EXPLORE THE CODE →</p>
+                <a href="https://github.com/Eric-Chung-0511/Learning-Record/tree/main/Data%20Science%20Projects/PawMatchAI" style="text-decoration: none;">
+                    <img src="https://img.shields.io/badge/GitHub-PawMatch_AI-007ACC?logo=github&style=for-the-badge">
+                </a>
+            </div>
+        ''')
+
+    return iface
+
+if __name__ == "__main__":
+    iface = main()
+    iface.launch()

style_transfer.py

@@ -0,0 +1,752 @@
+import torch
+from PIL import Image, ImageEnhance
+import numpy as np
+import gradio as gr
+from diffusers import StableDiffusionImg2ImgPipeline
+import time
+import os
+import base64
+from io import BytesIO
+
+class DogStyleTransfer:
+    """
+    Class for handling dog image style transfer using Stable Diffusion.
+    This class manages model loading, image preprocessing, and style transfer operations.
+    """
+    def __init__(self):
+        self.models = {}
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+
+        # Check xformers availability
+        self.xformers_available = False
+        try:
+            import xformers
+            self.xformers_available = True
+            print(f"xformers {xformers.__version__} is available and will be used for memory-efficient attention")
+        except ImportError:
+            print("xformers not found - will use default attention mechanism")
+        except Exception as e:
+            print(f"Error checking xformers: {str(e)} - will use default attention mechanism")
+
+        # Define style to model mapping based on availability
+        if self.device == "cuda":
+            self.style_model_mapping = {
+                "Japanese Anime Style": "Linaqruf/anything-v3.0",  # Specialized for anime style
+                "Classic Cartoon": "nitrosocke/mo-di-diffusion",   # Specialized for Disney style
+                "Oil Painting": "runwayml/stable-diffusion-v1-5",  # Original model good for painting styles
+                "Watercolor": "dreamlike-art/dreamlike-photoreal-2.0",  # Photorealistic art style model
+                "Cyberpunk": "dreamlike-art/dreamlike-diffusion-1.0"  # Dreamlike style model
+            }
+        else:
+            # Lightweight models for CPU mode
+            self.style_model_mapping = {
+                "Japanese Anime Style": "runwayml/stable-diffusion-v1-5",
+                "Classic Cartoon": "runwayml/stable-diffusion-v1-5",
+                "Oil Painting": "runwayml/stable-diffusion-v1-5",
+                "Watercolor": "runwayml/stable-diffusion-v1-5",
+                "Cyberpunk": "runwayml/stable-diffusion-v1-5"
+            }
+
+        # style prompts with each feature 
+        self.style_prompts = {
+            "Japanese Anime Style": "masterpiece, highest quality, genuine anime style illustration of a (dog:1.5), (bold anime aesthetics:1.5), (vibrant saturated colors:1.3), clean distinct lineart, stylized simplified features, expressive anime eyes, (preserve exact animal species:1.8), (maintain original animal breed:1.7), distinctive animal characteristics, (iconic anime art style:1.4), dramatic shading, flat color areas with highlight accents, simplified background elements, characteristic anime proportions, retain animal identity while stylizing, professional anime production quality, no watermarks, no signatures, (do not change animal species:1.8)",
+            "Classic Cartoon": "masterpiece, highest quality classic cartoon illustration of a dog, (golden age animation style:1.3), hand-drawn cel animation quality, bold clean outlines, (vibrant solid color fills:1.2), exaggerated expressive features, playful animated poses, classic Disney/Pixar influenced design, professional animation studio quality, simplified but expressive details, perfect smooth linework, rounded stylized forms, cheerful color palette, dynamic motion lines, classic cartoon physics, expressive oversized eyes, joyful personality captured, squash and stretch principles applied, classic cartoon proportions, professional character design, perfect animation keyframe quality, appealing character expression, masterful use of simple shapes, iconic cartoon aesthetic, no watermarks, no signatures",
+            "Oil Painting": "masterpiece, museum quality oil painting of a dog, (impasto technique:1.3), visible textured brushstrokes, layered oil pigments, rich depth of color, classical composition, (dramatic chiaroscuro lighting:1.2), Renaissance painting technique, glazing layers, sophisticated color harmony, warm and cool tones balance, expert painterly details, canvas texture visible, traditional realistic portrait style, fine art quality, gallery exhibition standard, rich shadows and highlights, volumetric form definition, atmospheric perspective, professional oil painting techniques, traditional varnished finish, color complexity with subtle undertones, expertly captured fur textures, strong compositional focus, emotional depth, timeless artistic quality, no watermarks, no signatures",
+            "Watercolor": "masterpiece, highest quality watercolor painting of a dog, (wet-on-wet technique:1.3), flowing color blends, translucent paint layers, visible paper texture, (controlled paint blooms:1.2), delicate color washes, spontaneous paint flow, preserved white spaces, soft color bleeding effects, subtle granulation textures, feathered edges, luminous transparency, loose expressive brushwork, artistic color pooling, gradient color transitions, minimalist background, playful splatter accents, artistic negative space usage, light-filled composition, watercolor paper grain visible, atmospheric color diffusion, professional traditional watercolor techniques, delicate brush details combined with flowing textures, no watermarks, no signatures",
+            "Cyberpunk": "masterpiece, highest quality, hyper-detailed cyberpunk digital art of a dog, (advanced technological integration:1.4), holographic collar interface, bionic limb enhancements, neural implant visuals, data visualization overlay, augmented reality HUD elements, (neon light reflections:1.3), wet street reflections, volumetric fog effects, urban dystopian background, megacity skyline, glowing circuitry details, optical fiber accents, synthetic materials, dramatic neon-lit contrast, cybernetic enhancements, high tech visors, digital distortion effects, information flow visualization, glitchy textures, metallic surfaces with advanced patina, dark atmospheric tone with vibrant neon accents, electrical energy effects, retro-futuristic design elements, near-future technology aesthetic, no watermarks, no signatures"
+        }
+
+        # Feature preservation prompts with weighted emphasis
+        self.feature_preservation = {
+            "common": "faithful representation of original animal species:(1.6), preserve original animal face structure:(1.5), maintain exact species characteristics:(1.4), accurate distinctive features:(1.3), consistent anatomical structure:(1.2), recognizable animal identity",
+            "Japanese Anime Style": "anime style dog with preserved realistic proportions, distinctive dog breed characteristics maintained, dog facial features clearly recognizable",
+            "Classic Cartoon": "cartoon style with accurate dog proportions, characteristic breed features preserved, recognizable dog expressions",
+            "Oil Painting": "oil painting technique while maintaining anatomical accuracy, realistic dog proportions, distinctive breed characteristics",
+            "Watercolor": "watercolor aesthetic with precise breed representation, accurate dog anatomy, distinctive dog features preserved",
+            "Cyberpunk": "cyberpunk elements while maintaining accurate dog proportions, recognizable breed features, true-to-life dog expression"
+        }
+
+        # Negative prompts
+        self.negative_prompts = {
+            "common": "deformed, distorted, disfigured, poorly drawn, bad anatomy, wrong anatomy, extra limbs, missing limbs, floating limbs, disconnected limbs, mutation, mutated, ugly, disgusting, blurry, amputation, watermark, signature, text, change of species, wrong animal species, incorrect animal type, different animal, human features",
+            "dog_specific": "human face, human features, anthropomorphic, humanoid, human-like features, cartoon eyes, unrealistic eyes",
+            "Japanese Anime Style": "photorealistic, 3d render, western cartoon style, pixar style, realistic textured skin",
+            "Classic Cartoon": "anime style, manga, realistic, detailed skin texture, painterly, sketch, watercolor style",
+            "Oil Painting": "flat colors, digital art, cartoon, cell shaded, smooth texture, anime style",
+            "Watercolor": "digital art, 3d render, vector art, perfect linework, hard edges, bold lines",
+            "Cyberpunk": "watercolor paint, oil painting, natural scene, traditional art, vintage style, soft colors",
+            "species_preservation": "species transformation, change of animal type, incorrect animal features, wrong animal proportions, mixed animal characteristics"
+        }
+
+        # Style descriptions for UI display
+        self.style_descriptions = {
+            "Japanese Anime Style": "Characterized by vibrant colors, large expressive eyes, and stylized features common in Japanese animation.",
+            "Classic Cartoon": "Friendly, rounded features with bold outlines and bright colors typical of classic animated films.",
+            "Oil Painting": "Rich textures and depth created through visible brushstrokes and layered color application.",
+            "Watercolor": "Soft, transparent washes of color with flowing transitions and subtle color blending.",
+            "Cyberpunk": "Futuristic sci-fi aesthetic with neon colors, high contrast, and technological elements."
+        }
+
+        # Set model cache path
+        self.model_cache_dir = os.path.join(os.path.expanduser("~"), ".cache", "dog_style_transfer")
+        os.makedirs(self.model_cache_dir, exist_ok=True)
+
+        # Display system info for debugging
+        self._print_system_info()
+
+    def _print_system_info(self):
+        """Print system information for debugging purposes"""
+        print("\n===== System Information =====")
+        print(f"Device: {self.device}")
+        print(f"PyTorch version: {torch.__version__}")
+
+        if self.device == "cuda":
+            print(f"CUDA available: {torch.cuda.is_available()}")
+            print(f"CUDA version: {torch.version.cuda if hasattr(torch.version, 'cuda') else 'Unknown'}")
+            print(f"GPU: {torch.cuda.get_device_name(0) if torch.cuda.is_available() else 'Not available'}")
+            print(f"GPU memory: {torch.cuda.get_device_properties(0).total_memory / 1024**3:.2f} GB" if torch.cuda.is_available() else "Not available")
+
+        print(f"xformers available: {self.xformers_available}")
+        print("============================\n")
+
+    def load_model(self, style_name):
+        """Load the appropriate model based on style, handling xformers compatibility"""
+        # Get model ID for the style
+        model_id = self.style_model_mapping.get(style_name, "runwayml/stable-diffusion-v1-5")
+
+        # Check if model is already loaded
+        if model_id not in self.models:
+            print(f"Loading model {model_id} for {style_name} style...")
+
+            try:
+                # Load model with cache directory
+                model = StableDiffusionImg2ImgPipeline.from_pretrained(
+                    model_id,
+                    cache_dir=self.model_cache_dir,
+                    torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                    safety_checker=None  # Remove safety checker to improve speed
+                )
+
+                if self.device == "cuda":
+                    model = model.to("cuda")
+                    # Enable memory optimization
+                    model.enable_attention_slicing()
+
+                    # Try to enable xformers
+                    try:
+                        if hasattr(model, 'enable_xformers_memory_efficient_attention'):
+                            print("Attempting to enable xformers memory efficient attention...")
+                            model.enable_xformers_memory_efficient_attention()
+                            print("xformers memory efficient attention enabled successfully!")
+                    except Exception as e:
+                        print(f"Warning: Could not enable xformers memory efficient attention: {e}")
+                        print("Proceeding without xformers optimization - this may use more memory but should still work.")
+
+                # Store model
+                self.models[model_id] = model
+                print(f"Model {model_id} loaded successfully!")
+            except Exception as e:
+                print(f"Error loading model {model_id}: {str(e)}")
+                # Fall back to basic model if specific model fails
+                if model_id != "runwayml/stable-diffusion-v1-5":
+                    print("Falling back to default model...")
+                    return self.load_model("Oil Painting")  # Use generic model as fallback
+                raise
+
+        return self.models[model_id]
+
+    def preprocess_image(self, image, animal_type='dog'):
+        """Enhanced preprocessing for dog images before style transfer"""
+        # Convert to PIL image if needed
+        if isinstance(image, np.ndarray):
+            # Handle RGBA images by converting to RGB
+            if image.shape[2] == 4:
+                image = image[:, :, :3]
+            image = Image.fromarray(np.uint8(image))
+
+        # Resize while maintaining aspect ratio
+        width, height = image.size
+        max_size = 512  # SD models typically use 512x512 input
+        scaling_factor = min(max_size / width, max_size / height)
+        new_width = int(width * scaling_factor)
+        new_height = int(height * scaling_factor)
+        image = image.resize((new_width, new_height), Image.LANCZOS)
+
+        # Enhance contrast to emphasize dog features
+        enhancer = ImageEnhance.Contrast(image)
+        image = enhancer.enhance(1.2)  # Slightly enhance contrast
+
+        # Sharpen to improve detail
+        enhancer = ImageEnhance.Sharpness(image)
+        image = enhancer.enhance(1.3)  # Enhance sharpness
+
+        # Pad if not 512x512, instead of cropping
+        if new_width != 512 or new_height != 512:
+            new_img = Image.new("RGB", (512, 512), (255, 255, 255))
+            # Center the resized image
+            offset = ((512 - new_width) // 2, (512 - new_height) // 2)
+            new_img.paste(image, offset)
+            image = new_img
+
+        if animal_type != 'dog':
+            self.feature_preservation['common'] = 'strict preservation of original animal species:(1.8),' + self.feature_preservation["common"]
+
+        return image
+
+    def transform_style(self, image, style_name, strength=0.75, guidance_scale=7.5):
+        """
+        Transform image to selected style with improved prompts and parameters
+
+        Args:
+            image: Input image
+            style_name: Name of the style to apply
+            strength: Style transformation strength (0-1)
+            guidance_scale: Guidance scale for stable diffusion
+
+        Returns:
+            tuple: (transformed_image, error_message)
+        """
+        try:
+            if image is None:
+                return None, "Please upload a dog image first!"
+
+            start_time = time.time()
+            print(f"Starting style transfer: {style_name}")
+
+            # Adjust parameters based on style
+            if style_name == "Japanese Anime Style":
+                guidance_scale = 9.0  # Higher guidance for anime style
+                strength = 0.8
+                num_steps = 50
+            elif style_name == "Classic Cartoon":
+                guidance_scale = 8.0
+                strength = 0.75
+                num_steps = 40
+            elif style_name == "Oil Painting" or style_name == "Watercolor":
+                guidance_scale = 8.0  # Medium guidance for art styles
+                strength = 0.85
+                num_steps = 50
+            elif style_name == "Cyberpunk":
+                guidance_scale = 10.0  # Very high guidance for cyberpunk
+                strength = 0.85
+                num_steps = 50
+            else:
+                num_steps = 40
+
+            # Load model for style
+            try:
+                pipe = self.load_model(style_name)
+            except Exception as e:
+                print(f"Failed to load specific model for {style_name}: {str(e)}")
+                # Fall back to default model
+                pipe = self.load_model("Oil Painting")
+
+            # Enhanced image preprocessing
+            pil_image = self.preprocess_image(image)
+
+            # Get style prompt and add feature preservation
+            base_prompt = self.style_prompts.get(style_name, "digital art style, a dog")
+
+            # Feature preservation prompts - combining common and style-specific
+            feature_preservation = f"{self.feature_preservation['common']}, {self.feature_preservation.get(style_name, '')}"
+
+            # Enhanced positive prompt with feature preservation
+            prompt = f"{base_prompt}, {feature_preservation}, (high quality, detailed, sharp focus, professional photography):(1.2)"
+
+            # Use negative prompt - combining common and style-specific
+            negative_prompt = f"{self.negative_prompts['common']}, {self.negative_prompts['dog_specific']}, {self.negative_prompts.get(style_name, '')}"
+
+            print(f"Using prompt: {prompt}")
+            print(f"Using negative prompt: {negative_prompt}")
+            print(f"Transformation parameters - Strength: {strength}, Guidance Scale: {guidance_scale}, Steps: {num_steps}")
+
+            # Limit steps if too large to avoid memory issues
+            if num_steps > 60 and self.device == "cuda":
+                print("Reducing inference steps to save memory")
+                num_steps = 60
+
+            try:
+                # Generate transformed image
+                result = pipe(
+                    prompt=prompt,
+                    negative_prompt=negative_prompt,
+                    image=pil_image,
+                    strength=strength,
+                    guidance_scale=guidance_scale,
+                    num_inference_steps=num_steps
+                ).images[0]
+
+            except RuntimeError as e:
+                # Handle CUDA out of memory errors
+                if "CUDA out of memory" in str(e):
+                    print("CUDA out of memory error, trying with reduced parameters")
+                    # Retry with lower settings
+                    return self._retry_with_lower_settings(pipe, prompt, negative_prompt, pil_image, strength, guidance_scale)
+                else:
+                    # Try without negative prompt
+                    print(f"Error with negative prompt, retrying without it: {str(e)}")
+                    try:
+                        result = pipe(
+                            prompt=prompt,
+                            image=pil_image,
+                            strength=strength,
+                            guidance_scale=guidance_scale,
+                            num_inference_steps=30  # Reduce steps
+                        ).images[0]
+                    except Exception as retry_error:
+                        print(f"Retry also failed: {str(retry_error)}")
+                        raise
+
+            proc_time = time.time() - start_time
+            print(f"Style transfer completed in {proc_time:.2f} seconds")
+
+            return np.array(result), None
+
+        except Exception as e:
+            error_message = str(e)
+            # Provide user-friendly error messages
+            if "xformers" in error_message.lower():
+                print(f"xformers related error: {error_message}")
+                return None, "Style transfer error: xformers optimization unavailable, but functionality not affected. Please click 'Transform Style' button again to continue."
+            elif "CUDA out of memory" in error_message:
+                print(f"CUDA memory error: {error_message}")
+                return None, "GPU memory insufficient. Try reducing parameters or using a smaller image."
+            else:
+                print(f"Error during style transfer: {error_message}")
+                return None, f"Style transfer error: {error_message}"
+
+
+    def _retry_with_lower_settings(self, pipe, prompt, negative_prompt, image, strength, guidance_scale):
+        """Retry with lower settings when memory is insufficient"""
+        try:
+            # First attempt: Reduce inference steps
+            print("Attempting with lower settings (steps=20)...")
+            result = pipe(
+                prompt=prompt,
+                negative_prompt=negative_prompt,
+                image=image,
+                strength=strength,
+                guidance_scale=guidance_scale,
+                num_inference_steps=20  # Significantly reduce steps
+            ).images[0]
+            return np.array(result), None
+
+        except Exception as first_error:
+            # Log first failure
+            print(f"First retry attempt failed: {str(first_error)}")
+
+            # Second attempt: Minimum settings
+            try:
+                print("Attempting with minimum settings (steps=15, strength=0.6)...")
+                result = pipe(
+                    prompt=prompt,
+                    image=image,
+                    strength=0.6,  # Lower strength
+                    guidance_scale=7.0,  # Use standard setting
+                    num_inference_steps=15  # Minimum steps
+                ).images[0]
+                return np.array(result), None
+
+            except Exception as second_error:
+                # Log all failures
+                print(f"Second retry attempt also failed: {str(second_error)}")
+                print("All retry attempts failed")
+
+                # Return clear error message
+                error_msg = f"Unable to complete style transfer, even with minimal settings: {str(second_error)}"
+                return None, error_msg
+
+    def get_available_styles(self):
+        """Get all available style options"""
+        return list(self.style_prompts.keys())
+
+    def get_style_description(self, style_name):
+        """Get description for a specific style"""
+        return self.style_descriptions.get(style_name, "")
+
+    def get_model_info(self, style_name):
+        """Get the model information for a specific style"""
+        model_id = self.style_model_mapping.get(style_name, "runwayml/stable-diffusion-v1-5")
+        return f"Powered by: {model_id}"
+
+    def get_image_download_link(self, image):
+        """
+        Generate a data URL for downloading the image
+
+        Args:
+            image: PIL Image or numpy array
+
+        Returns:
+            str: Base64 encoded data URL
+        """
+        if image is None:
+            return None
+
+        # Convert numpy array to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(np.uint8(image))
+
+        # Save image to bytes buffer
+        buffer = BytesIO()
+        image.save(buffer, format="PNG")
+        img_str = base64.b64encode(buffer.getvalue()).decode()
+
+        return f"data:image/png;base64,{img_str}"
+
+def create_style_transfer_tab(dog_style_transfer):
+    """Create style transfer tab with UI components"""
+
+    with gr.Column():
+        gr.Markdown("""
+        # 🎨 Dog Style Transformation
+
+        Transform your dog photos into different artistic styles! Upload a dog picture, choose your preferred style, and create unique artwork.
+        """)
+
+        # Add model info and style description display
+        gr.Markdown("""
+        <div style="background-color: #f0f8ff; padding: 16px; border-radius: 8px; margin: 16px 0; border: 1px solid #cce5ff; box-shadow: 0 3px 10px rgba(0,0,123,0.1);">
+            <h3>🐶 Upload a dog photo and select an artistic style</h3>
+            <p>After uploading your dog photo, the system will transform it into your chosen artistic style. Try different styles to create stunning effects!</p>
+            <p>Our system uses specialized models for each style to ensure the best results.</p>
+            <p style="margin-top: 10px; padding: 8px; background-color: #fff9e6; border-left: 4px solid #ffd966; border-radius: 4px;"><b>⏱️ Patience is a virtue!</b> While AI is working its magic, your dog might have time to learn a new trick or two. The transformation can take up to 30 seconds, depending on how photogenic your furry friend is! 🐾</p>
+            <p style="margin-top: 10px; padding: 8px; background-color: #e6f9ff; border-left: 4px solid #66c2ff; border-radius: 4px;"><b>🤫 A Little Secret:</b> Although we designed this tool for dogs, it can actually transform any photo! Portraits, landscapes, even your favorite teddy bear — feel free to try them all! Just don’t tell the other dogs… they might get jealous! 😉</p>
+            <p style="margin-top: 10px; padding: 8px; background-color: #e6f9e6; border-left: 4px solid #66cc77; border-radius: 4px;"><b>✨ Unlimited Creativity!</b> Sometimes, AI might surprise you with unexpected creative interpretations, adding unique colors or features to your image. ✨</p>
+        </div>
+        """)
+
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Upload image component
+                input_image = gr.Image(
+                    label="Upload Dog Photo",
+                    type="numpy"
+                )
+
+                style_dropdown = gr.Dropdown(
+                    choices=dog_style_transfer.get_available_styles(),
+                    value=dog_style_transfer.get_available_styles()[0],
+                    label="Select Artistic Style"
+                )
+
+                # Display style description
+                style_description = gr.Markdown(
+                    dog_style_transfer.get_style_description(dog_style_transfer.get_available_styles()[0])
+                )
+
+                # Display model info
+                model_info = gr.Markdown(
+                    dog_style_transfer.get_model_info(dog_style_transfer.get_available_styles()[0])
+                )
+
+                with gr.Row():
+                    strength_slider = gr.Slider(
+                        minimum=0.3,
+                        maximum=0.9,
+                        value=0.75,
+                        step=0.05,
+                        label="Style Intensity (lower values preserve more original details)"
+                    )
+
+                # customize Transform style buttom
+                style_button = gr.Button("Transform Style", variant="primary")
+
+                gr.Markdown("""
+                <style>
+                button.primary {
+                    background: linear-gradient(90deg, #ff6b6b, #ffa36b, #ffd56b) !important;
+                    color: white !important;
+                    font-weight: 600 !important;
+                    text-shadow: 0 1px 1px rgba(0,0,0,0.2) !important;
+                    border: none !important;
+                }
+
+                button.primary:hover {
+                    background: linear-gradient(90deg, #ff5b5b, #ff936b, #ffcf6b) !important;
+                    box-shadow: 0 4px 8px rgba(0,0,0,0.3) !important;
+                }
+                </style>
+                """)
+
+                # Progress indicator
+                status_indicator = gr.Textbox(
+                    label="Status",
+                    value="Upload an image and press 'Transform Style' to begin",
+                    interactive=False
+                )
+
+                error_output = gr.Textbox(
+                    visible=False,
+                    label="Error Message"
+                )
+
+            with gr.Column(scale=1):
+                # Output image component
+                output_image = gr.Image(
+                    label="Style Transformation Result"
+                )
+
+                # Hidden component to store the download link
+                download_link = gr.HTML(visible=False)
+
+                # HTML component for actual download
+                download_html = gr.HTML(visible=False)
+
+                gr.Markdown("""
+                ### Tips for Best Results
+                - Use images with clear dog features and good lighting
+                - For best results, use images where the dog is the main subject
+                - Different styles work better with different dog breeds
+                - Lower the style intensity to preserve more original details
+                """)
+
+        gr.HTML("""
+            <style>
+            .style-box {
+                background: linear-gradient(145deg, #ffffff, #f5f7fa);
+                border-radius: 12px;
+                box-shadow: 0 4px 20px rgba(0,0,0,0.08);
+                padding: 25px 30px;
+                margin: 30px 0;
+                border: 1px solid rgba(0,0,0,0.05);
+                position: relative;
+            }
+
+            .style-box::before {
+                content: '';
+                position: absolute;
+                top: 0;
+                left: 0;
+                width: 6px;
+                height: 100%;
+                background: linear-gradient(to bottom, #ff6b6b, #ffa36b, #ffd56b);
+                border-radius: 6px 0 0 6px;
+            }
+
+            .style-box h2 {
+                color: #333;
+                font-size: 24px;
+                margin-bottom: 20px;
+                padding-bottom: 10px;
+                border-bottom: 2px solid #f0f0f0;
+            }
+
+            .style-name {
+                font-weight: bold;
+                color: #333;
+            }
+
+            .style-desc {
+                margin-bottom: 15px;
+                padding-bottom: 15px;
+                border-bottom: 1px solid #f0f0f0;
+            }
+
+            .style-desc:last-child {
+                margin-bottom: 0;
+                padding-bottom: 0;
+                border-bottom: none;
+            }
+            </style>
+
+            <div class="style-box">
+                <h2>Style Effect Descriptions</h2>
+                <p>Each style transforms your dog photo in a unique way:</p>
+                
+                <div class="style-desc">
+                    <p><span class="style-name">Japanese Anime Style:</span> Vibrant artwork with fluid animation qualities, expressive features, and dramatic lighting effects. Features soft color gradients, detailed line work, and emotional depth.</p>
+                </div>
+                
+                <div class="style-desc">
+                    <p><span class="style-name">Classic Cartoon:</span> Traditional animation style with bold outlines, solid color fills, and playful character design. Displays exaggerated expressions, simplified forms, and dynamic poses.</p>
+                </div>
+                
+                <div class="style-desc">
+                    <p><span class="style-name">Oil Painting:</span> Classical art technique with visible textured brushstrokes and layered color application. Shows rich depth, dramatic lighting contrast, and sophisticated color harmony.</p>
+                </div>
+                
+                <div class="style-desc">
+                    <p><span class="style-name">Watercolor:</span> Delicate painting style with flowing color blends and translucent layers. Features soft edges, color bleeding effects, and visible paper texture elements.</p>
+                </div>
+                
+                <div class="style-desc">
+                    <p><span class="style-name">Cyberpunk:</span> High-tech futuristic aesthetic with advanced technological elements and neon accents. Incorporates holographic interfaces, digital effects, and urban dystopian elements.</p>
+                </div>
+            </div>
+            """)
+
+        # Setup event triggers
+        def update_progress(value, desc):
+            """Update progress bar and description"""
+            return gr.update(value=value), gr.update(value=desc)
+
+        def process_style_transfer(image, style, strength):
+            """Process style transfer and prepare download options"""
+            if image is None:
+                return (
+                    None,
+                    gr.update(visible=True, value="Please upload a dog image first!"),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(value="Upload an image and press 'Transform Style' to begin")
+                )
+
+            # Display processing status
+            status_message = "Processing your image... This may take a moment."
+
+            # Perform style transfer
+            result, error = dog_style_transfer.transform_style(
+                image,
+                style,
+                strength
+            )
+
+            if error:
+                return (
+                    None,
+                    gr.update(visible=True, value=error),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(value="Error occurred. Please try again.")
+                )
+
+            # Generate download link for the image
+            if result is not None:
+                pil_image = Image.fromarray(result)
+                download_data = dog_style_transfer.get_image_download_link(pil_image)
+                download_html_content = f"""
+                <style>
+                .download-btn {{
+                    display: inline-block;
+                    background: linear-gradient(90deg, #3498db, #2ecc71);
+                    color: white !important; /* 確保文字為白色 */
+                    text-shadow: 0 1px 2px rgba(0,0,0,0.3) !important; /* 增強文字陰影使白色更突出 */
+                    font-weight: 700 !important; /* 加粗字體 */
+                    padding: 12px 24px;
+                    text-align: center;
+                    text-decoration: none;
+                    font-size: 16px;
+                    border-radius: 25px;
+                    cursor: pointer;
+                    transition: all 0.3s ease;
+                    border: none;
+                    box-shadow: 0 3px 6px rgba(0,0,0,0.16);
+                    letter-spacing: 0.5px; /* 字母間距，提高可讀性 */
+                }}
+
+                .download-btn:hover {{
+                    transform: translateY(-2px);
+                    box-shadow: 0 5px 10px rgba(0,0,0,0.25);
+                    background: linear-gradient(90deg, #2980b9, #27ae60);
+                }}
+
+                .download-btn:active {{
+                    transform: translateY(0);
+                    box-shadow: 0 2px 4px rgba(0,0,0,0.1);
+                }}
+                </style>
+
+                <a href="{download_data}" download="dog_{style.replace(' ', '_')}.png" class="download-btn">
+                    Download Transformed Image
+                </a>
+                """
+
+                # Store download data in a hidden element
+                # We'll make this invisible to avoid showing base64 encoded data
+                hidden_download_data = download_data
+
+                return (
+                    result,
+                    gr.update(visible=False),
+                    gr.update(visible=False, value=hidden_download_data),  # Keep the data hidden
+                    gr.update(visible=True, value=download_html_content),  # Show the HTML button
+                    gr.update(value="Transform Completed! You can download the image")
+                )
+            else:
+                # Handle the case where result is None but no error was returned
+                return (
+                    None,
+                    gr.update(visible=True, value="Style transfer failed with no specific error. Please try again."),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(visible=False),
+                    gr.update(value="Something went wrong. Please try again.")
+                )
+
+        # Update style description and model info
+        def update_style_info(style):
+            return dog_style_transfer.get_style_description(style), dog_style_transfer.get_model_info(style)
+
+        style_button.click(
+            fn=process_style_transfer,
+            inputs=[input_image, style_dropdown, strength_slider],
+            outputs=[
+                output_image,
+                error_output,
+                download_link,
+                download_html,
+            ]
+        )
+
+        style_dropdown.change(
+            fn=update_style_info,
+            inputs=[style_dropdown],
+            outputs=[style_description, model_info]
+        )
+
+
+        # Add example images
+        example_dogs = [
+            ["Border_Collie.jpg", "Japanese Anime Style"],
+            ["Golden_Retriever.jpeg", "Classic Cartoon"],
+            ["Saint_Bernard.jpeg", "Oil Painting"],
+            ["Samoyed.jpeg", "Watercolor"],
+            ["French_Bulldog.jpeg", "Cyberpunk"]
+        ]
+
+        # Check if Examples feature is available
+        try:
+            gr.Examples(
+                examples=example_dogs,
+                inputs=[input_image, style_dropdown]
+            )
+        except Exception as e:
+            print(f"Note: Examples feature not available in your Gradio version: {e}")
+
+        gr.HTML("""
+            <style>
+            .attribution-box {
+                font-size: 0.85em;
+                color: #666;
+                margin-top: 20px;
+                padding: 18px;
+                border-radius: 8px;
+                background-color: #f8f9fa;
+                border: 1px solid #e9ecef;
+                font-style: italic;
+            }
+
+            .attribution-box h4 {
+                margin-top: 0;
+                color: #495057;
+                font-style: normal;
+                font-weight: 600;
+                margin-bottom: 12px;
+            }
+
+            .attribution-box p {
+                margin: 8px 0;
+                line-height: 1.5;
+            }
+            </style>
+
+            <div class="attribution-box">
+                <h4>Attribution</h4>
+                <p>This application uses pre-trained diffusion models from Hugging Face for image style transfer. All models are used according to their respective open source licenses for educational and non-commercial purposes.</p>
+                <p>Powered by the open source Diffusers library from Hugging Face.</p>
+            </div>
+            """)
+
+    return input_image, style_dropdown, style_button, output_image