Initial fresh commit with LFS

.gitattributes

@@ -0,0 +1,2 @@
+*.keras filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,489 @@
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+import cv2
+import pickle
+import os
+import tempfile
+from PIL import Image
+
+class MultiAttributeClassifier:
+    def __init__(self):
+        self.models = {}
+        self.encoders = {}
+        self.gan_models = {}
+        self.confidence_threshold = 0.6
+        self.categories = ['content', 'style', 'time_of_day', 'weather']
+        self.load_classification_models()
+        self.load_gan_models()
+    
+    def load_classification_models(self):
+        """Load all classification models and encoders"""
+        print("Loading classification models...")
+        
+        for category in self.categories:
+            try:
+                # Load model from correct path
+                model_path = f"models/classification/{category}_model.h5"
+                if os.path.exists(model_path):
+                    self.models[category] = tf.keras.models.load_model(model_path)
+                    print(f"✅ Loaded {category} model")
+                    
+                    # Load encoder
+                    encoder_path = f"models/classification/{category}_encoder.pkl"
+                    if os.path.exists(encoder_path):
+                        with open(encoder_path, 'rb') as f:
+                            self.encoders[category] = pickle.load(f)
+                    else:
+                        print(f"⚠️ {category} encoder not found")
+                else:
+                    print(f"⚠️ {category} model not found at {model_path}")
+            except Exception as e:
+                print(f"❌ Failed to load {category}: {e}")
+    
+    def load_gan_models(self):
+        """Load all GAN models for style transfer"""
+        print("Loading GAN models...")
+        
+        gan_paths = {
+            # Day/Night models
+            'day_to_night': 'models/gan/day_night/day_to_night_generator_final.keras',
+            'night_to_day': 'models/gan/day_night/night_to_day_generator_final.keras',
+            
+            # Foggy/Clear models  
+            'foggy_to_clear': 'models/gan/foggy/foggy_to_normal_generator_final.keras',
+            'clear_to_foggy': 'models/gan/foggy/normal_to_foggy_generator_final.keras',
+            
+            # Japanese art models
+            'photo_to_japanese': 'models/gan/japanese/photo_to_ukiyoe_generator.keras',
+            'japanese_to_photo': 'models/gan/japanese/ukiyoe_to_photo_generator.keras',
+            
+            # Season models
+            'summer_to_winter': 'models/gan/summer_winter/summer_to_winter_generator_final.keras',
+            'winter_to_summer': 'models/gan/summer_winter/winter_to_summer_generator_final.keras'
+        }
+        
+        for model_name, model_path in gan_paths.items():
+            try:
+                if os.path.exists(model_path):
+                    self.gan_models[model_name] = tf.keras.models.load_model(model_path)
+                    print(f"✅ Loaded GAN: {model_name}")
+                else:
+                    print(f"⚠️ GAN model not found: {model_path}")
+            except Exception as e:
+                print(f"❌ Failed to load GAN {model_name}: {e}")
+    
+    def preprocess_image_for_classification(self, image_path):
+        """Preprocess image for classification (224x224)"""
+        img = cv2.imread(image_path)
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = cv2.resize(img, (224, 224))
+        img = img.astype(np.float32) / 255.0
+        img = (img - [0.485, 0.456, 0.406]) / [0.229, 0.224, 0.225]
+        img = np.expand_dims(img, axis=0)
+        return img
+    
+    def preprocess_image_for_gan(self, image_path, target_size=(256, 256)):
+        """Preprocess image for GAN models (256x256, normalized to [-1,1])"""
+        img = cv2.imread(image_path)
+        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
+        img = cv2.resize(img, target_size)
+        img = img.astype(np.float32)
+        img = (img / 127.5) - 1.0  # Normalize to [-1, 1]
+        img = np.expand_dims(img, axis=0)
+        return img
+    
+    def postprocess_gan_output(self, generated_img):
+        """Convert GAN output back to displayable image"""
+        # Convert from [-1, 1] to [0, 255]
+        img = (generated_img[0] + 1.0) * 127.5
+        img = np.clip(img, 0, 255).astype(np.uint8)
+        return Image.fromarray(img)
+    
+    def classify_image(self, image_path):
+        """Classify image across all loaded attributes"""
+        img = self.preprocess_image_for_classification(image_path)
+        results = {}
+        
+        for category in self.categories:
+            if category in self.models and category in self.encoders:
+                try:
+                    # Get predictions
+                    predictions = self.models[category].predict(img, verbose=0)
+                    if len(predictions.shape) > 1:
+                        predictions = predictions[0]
+                    
+                    # Get class names
+                    class_names = list(self.encoders[category].keys())
+                    predicted_idx = np.argmax(predictions)
+                    confidence = float(predictions[predicted_idx])
+                    predicted_class = class_names[predicted_idx]
+                    
+                    # Get top predictions
+                    top_indices = np.argsort(predictions)[-3:][::-1]
+                    top_3 = [(class_names[i], float(predictions[i])) for i in top_indices]
+                    
+                    results[category] = {
+                        'predicted_class': predicted_class,
+                        'confidence': confidence,
+                        'is_confident': confidence >= self.confidence_threshold,
+                        'top_3': top_3
+                    }
+                    
+                except Exception as e:
+                    results[category] = {
+                        'predicted_class': 'error',
+                        'confidence': 0.0,
+                        'is_confident': False,
+                        'error': str(e)
+                    }
+        
+        return results
+    
+    def apply_gan_transformation(self, image_path, transformation_type):
+        """Apply GAN transformation to image"""
+        if transformation_type not in self.gan_models:
+            return None, f"GAN model '{transformation_type}' not available"
+        
+        try:
+            # Preprocess image for GAN
+            img = self.preprocess_image_for_gan(image_path)
+            
+            # Apply transformation
+            generated = self.gan_models[transformation_type].predict(img, verbose=0)
+            
+            # Postprocess result
+            result_image = self.postprocess_gan_output(generated)
+            
+            return result_image, "Success"
+            
+        except Exception as e:
+            return None, f"Error applying {transformation_type}: {str(e)}"
+
+def get_available_transfers(classification_results):
+    """Get available style transfers based on classifications"""
+    transfers = []
+    
+    for category, result in classification_results.items():
+        if not result.get('is_confident', False):
+            continue
+            
+        predicted = result['predicted_class']
+        confidence = result['confidence']
+        
+        if category == 'time_of_day':
+            if predicted == 'day':
+                transfers.append({
+                    'name': 'Day → Night',
+                    'gan_model': 'day_to_night',
+                    'confidence': confidence,
+                    'description': 'Transform daytime scene to nighttime'
+                })
+            elif predicted == 'night':
+                transfers.append({
+                    'name': 'Night → Day',
+                    'gan_model': 'night_to_day',
+                    'confidence': confidence,
+                    'description': 'Transform nighttime scene to daytime'
+                })
+        
+        elif category == 'style':
+            if predicted == 'photograph':
+                transfers.append({
+                    'name': 'Photo → Japanese Art',
+                    'gan_model': 'photo_to_japanese',
+                    'confidence': confidence,
+                    'description': 'Convert realistic photo to Japanese ukiyo-e art style'
+                })
+            elif predicted == 'japanese_art':
+                transfers.append({
+                    'name': 'Japanese Art → Photo',
+                    'gan_model': 'japanese_to_photo',
+                    'confidence': confidence,
+                    'description': 'Convert artistic style to realistic photo'
+                })
+        
+        elif category == 'weather':
+            if predicted == 'foggy':
+                transfers.append({
+                    'name': 'Foggy → Clear',
+                    'gan_model': 'foggy_to_clear',
+                    'confidence': confidence,
+                    'description': 'Remove fog and enhance visibility'
+                })
+            elif predicted == 'clear':
+                transfers.append({
+                    'name': 'Clear → Foggy',
+                    'gan_model': 'clear_to_foggy',
+                    'confidence': confidence,
+                    'description': 'Add atmospheric fog effect'
+                })
+    
+    # Add season transfers (these work regardless of season classification)
+    # You might want to add season classification logic here if you have a season model
+    transfers.extend([
+        {
+            'name': 'Add Winter Atmosphere',
+            'gan_model': 'summer_to_winter',
+            'confidence': 0.8,
+            'description': 'Transform scene to winter with snow and cold atmosphere'
+        },
+        {
+            'name': 'Add Summer Atmosphere', 
+            'gan_model': 'winter_to_summer',
+            'confidence': 0.8,
+            'description': 'Transform scene to summer with warm, lush atmosphere'
+        }
+    ])
+    
+    return transfers
+
+# Initialize classifier globally
+classifier = MultiAttributeClassifier()
+
+def analyze_image(image):
+    """Main analysis function"""
+    if image is None:
+        return "Please upload an image first!", gr.update(choices=[], visible=False), gr.update(visible=False)
+    
+    # Save uploaded image to temporary file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+        image.save(tmp_file.name)
+        temp_path = tmp_file.name
+    
+    try:
+        # Get classifications
+        results = classifier.classify_image(temp_path)
+        
+        # Format analysis results
+        analysis_text = "## 📊 Image Analysis Results\n\n"
+        
+        for category, result in results.items():
+            if 'error' not in result:
+                confidence = result['confidence']
+                status = "✅ CONFIDENT" if result['is_confident'] else "⚠️ UNCERTAIN"
+                predicted = result['predicted_class']
+                
+                analysis_text += f"**{category.replace('_', ' ').title()}:** {predicted} ({confidence:.1%}) {status}\n\n"
+                
+                # Show top alternatives
+                if len(result['top_3']) > 1:
+                    alt_text = ", ".join([f"{name} ({score:.1%})" for name, score in result['top_3'][1:]])
+                    analysis_text += f"   *Alternatives: {alt_text}*\n\n"
+            else:
+                analysis_text += f"**{category.replace('_', ' ').title()}:** Error - {result.get('error', 'Unknown error')}\n\n"
+        
+        # Get available transfers
+        transfers = get_available_transfers(results)
+        
+        if transfers:
+            analysis_text += "## 🎨 Available Style Transfers\n\n"
+            transfer_choices = []
+            
+            for transfer in transfers:
+                analysis_text += f"**{transfer['name']}** ({transfer['confidence']:.1%})\n"
+                analysis_text += f"*{transfer['description']}*\n\n"
+                transfer_choices.append(transfer['name'])
+        else:
+            analysis_text += "## ⚠️ No Style Transfers Available\n\n"
+            analysis_text += "Could not confidently classify the image for available transformations.\n\n"
+            transfer_choices = []
+        
+        return (
+            analysis_text,
+            gr.update(choices=transfer_choices, visible=len(transfer_choices) > 0),
+            gr.update(visible=len(transfer_choices) > 0)
+        )
+    
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}", gr.update(choices=[], visible=False), gr.update(visible=False)
+    
+    finally:
+        # Clean up temp file
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+def apply_style_transfer(original_image, selected_transfers):
+    """Apply selected style transfers using actual GAN models"""
+    if not selected_transfers:
+        return original_image, "⚠️ No transfers selected!"
+    
+    if original_image is None:
+        return None, "⚠️ No image provided!"
+    
+    # Save original image to temp file
+    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as tmp_file:
+        original_image.save(tmp_file.name)
+        temp_path = tmp_file.name
+    
+    result_text = "## 🎨 Applied Transformations\n\n"
+    current_image = original_image
+    
+    try:
+        # Map transfer names to GAN models
+        transfer_mapping = {
+            'Day → Night': 'day_to_night',
+            'Night → Day': 'night_to_day',
+            'Photo → Japanese Art': 'photo_to_japanese',
+            'Japanese Art → Photo': 'japanese_to_photo',
+            'Foggy → Clear': 'foggy_to_clear',
+            'Clear → Foggy': 'clear_to_foggy',
+            'Add Winter Atmosphere': 'summer_to_winter',
+            'Add Summer Atmosphere': 'winter_to_summer'
+        }
+        
+        # Apply each selected transformation
+        for transfer_name in selected_transfers:
+            if transfer_name in transfer_mapping:
+                gan_model = transfer_mapping[transfer_name]
+                
+                # Apply transformation
+                transformed_image, status = classifier.apply_gan_transformation(temp_path, gan_model)
+                
+                if transformed_image is not None:
+                    result_text += f"✅ **{transfer_name}** - {status}\n"
+                    current_image = transformed_image
+                    
+                    # Save transformed image for next transformation
+                    with tempfile.NamedTemporaryFile(delete=False, suffix='.jpg') as new_tmp:
+                        transformed_image.save(new_tmp.name)
+                        if os.path.exists(temp_path):
+                            os.unlink(temp_path)
+                        temp_path = new_tmp.name
+                else:
+                    result_text += f"❌ **{transfer_name}** - {status}\n"
+            else:
+                result_text += f"⚠️ **{transfer_name}** - Transfer not implemented\n"
+        
+        result_text += f"\n🎉 **Transformation{'s' if len(selected_transfers) > 1 else ''} complete!**\n\n"
+        
+        if len(selected_transfers) > 1:
+            result_text += "*Multiple transformations were applied in sequence for a combined effect.*"
+        
+        return current_image, result_text
+        
+    except Exception as e:
+        return original_image, f"❌ Error during transformation: {str(e)}"
+    
+    finally:
+        # Clean up temp file
+        if os.path.exists(temp_path):
+            os.unlink(temp_path)
+
+# Create Gradio interface
+with gr.Blocks(
+    title="🎨 Intelligent Style Transfer System",
+    theme=gr.themes.Soft()
+) as demo:
+    
+    gr.Markdown("""
+    # 🎨 Intelligent Multi-Attribute Style Transfer
+    
+    Upload an image and our AI will analyze multiple attributes (content, style, time, weather) 
+    and suggest relevant style transfers using trained GAN models!
+    
+    **Available Transformations:**
+    - 🌅 Day ↔ Night conversion (CycleGAN)
+    - 🎨 Photo ↔ Japanese Ukiyo-e art style (CycleGAN)
+    - 🌫️ Foggy ↔ Clear weather transformation (CycleGAN)
+    - 🌿 Summer ↔ Winter seasonal atmosphere (CycleGAN)
+    """)
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_image = gr.Image(
+                type="pil",
+                label="📤 Upload Your Image", 
+                height=400
+            )
+            
+            analyze_btn = gr.Button(
+                "🔍 Analyze Image",
+                variant="primary",
+                size="lg"
+            )
+        
+        with gr.Column(scale=1):
+            analysis_output = gr.Markdown(
+                value="Upload an image and click 'Analyze Image' to see what our AI detects!",
+                height=400
+            )
+    
+    with gr.Row():
+        transfer_selector = gr.CheckboxGroup(
+            label="🎨 Select Style Transfers to Apply",
+            choices=[],
+            visible=False
+        )
+    
+    with gr.Row():
+        apply_btn = gr.Button(
+            "✨ Apply Selected Transfers",
+            variant="secondary",
+            visible=False,
+            size="lg"
+        )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            output_image = gr.Image(
+                label="🎉 Transformed Image",
+                height=400
+            )
+        
+        with gr.Column(scale=1):
+            result_output = gr.Markdown(
+                value="Select transfers and click 'Apply' to see the magic happen!"
+            )
+    
+    # Example images (add some to your examples folder)
+    gr.Examples(
+        examples=[
+            ["examples/example(1).jpg"],
+            ["examples/example(2).jpg"], 
+            ["examples/example(3).jpg"],
+            ["examples/example(4).jpg"],
+            ["examples/example(5).jpg"], 
+            ["examples/example(6).jpg"],
+        ],
+        inputs=input_image,
+        label="🖼️ Try Example Images"
+    )
+    
+    # Connect the interface
+    analyze_btn.click(
+        fn=analyze_image,
+        inputs=[input_image],
+        outputs=[analysis_output, transfer_selector, apply_btn]
+    )
+    
+    apply_btn.click(
+        fn=apply_style_transfer,
+        inputs=[input_image, transfer_selector],
+        outputs=[output_image, result_output]
+    )
+    
+    gr.Markdown("""
+    ---
+    ### 🔧 Technical Details
+    
+    This system uses multiple trained models:
+    
+    **Classification Models:**
+    - **Content classifier**: Human vs Landscape (97% accuracy)
+    - **Style classifier**: Photograph vs Japanese Art (92% accuracy)  
+    - **Time classifier**: Day vs Night (90% accuracy)
+    - **Weather classifier**: Foggy vs Clear (85% accuracy)
+    
+    **GAN Models:**
+    - **Day/Night**: CycleGAN for time-of-day transformation
+    - **Style Transfer**: CycleGAN for photo ↔ Japanese art conversion
+    - **Weather**: CycleGAN for fog removal/addition
+    - **Seasons**: CycleGAN for summer ↔ winter atmosphere
+    
+    Only confident predictions (>60%) trigger relevant style transfer suggestions.
+    Multiple transformations can be combined for creative effects!
+    """)
+
+if __name__ == "__main__":
+    demo.launch()

models/classification/content_model.h5

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

models/classification/style_model.h5

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

models/classification/time_of_day_model.h5

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

models/classification/weather_model.h5

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

models/gan/day_night/day_to_night_generator_final.keras

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

models/gan/day_night/night_to_day_generator_final.keras

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

models/gan/foggy/foggy_to_normal_generator_final.keras

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

models/gan/foggy/normal_to_foggy_generator_final.keras

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

models/gan/japanese/old models/photo_to_ukiyoe_generator.keras

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

models/gan/japanese/old models/ukiyoe_to_photo_generator.keras

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

models/gan/japanese/photo_to_ukiyoe_generator.keras

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

models/gan/japanese/ukiyoe_to_photo_generator.keras

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

models/gan/summer_winter/summer_to_winter_generator_final.keras

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

models/gan/summer_winter/winter_to_summer_generator_final.keras

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

readme.md

@@ -0,0 +1,57 @@
+---
+title: Intelligent Style Transfer System
+emoji: 🎨
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: 4.44.0
+app_file: app.py
+pinned: false
+license: mit
+---
+
+# 🎨 Intelligent Multi-Attribute Style Transfer
+
+An AI-powered system that analyzes images across multiple attributes and intelligently suggests relevant style transfers.
+
+## Features
+
+- **Multi-Attribute Analysis**: Simultaneously classifies content, style, time of day, and weather
+- **Intelligent Recommendations**: Only suggests style transfers that make sense for your image
+- **User Choice**: Pick single effects or combine multiple transformations
+- **High Accuracy**: 90%+ accuracy on key classification tasks
+
+## How It Works
+
+1. **Upload** your image
+2. **AI Analysis** across 4 different attributes
+3. **Smart Suggestions** based on confident predictions
+4. **Apply** single or combined style transfers
+
+## Available Transformations
+
+- 🌅 Day ↔ Night conversion
+- 🎨 Photo ↔ Japanese Art style
+- 🌫️ Fog removal (Foggy → Clear)
+- 🖼️ Content-aware enhancement
+
+## Technical Details
+
+This system uses multiple trained CNN models:
+
+- **Content**: Human vs Landscape classification (97% accuracy)
+- **Style**: Photograph vs Japanese Art classification (92% accuracy)
+- **Time**: Day vs Night classification (90% accuracy)
+- **Weather**: Foggy vs Clear classification (85% accuracy)
+
+Only confident predictions (>60%) trigger style transfer suggestions, ensuring relevant recommendations.
+
+## Model Architecture
+
+- Base: ResNet50 and MobileNetV2 with ImageNet pretraining
+- Training: Transfer learning with data augmentation
+- Deployment: TensorFlow models optimized for inference
+
+---
+
+_Built with Gradio, TensorFlow, and ❤️_

requirements.txt

@@ -0,0 +1,7 @@
+gradio==4.44.0
+tensorflow==2.15.0
+opencv-python-headless==4.8.1.78
+Pillow==10.0.1
+numpy==1.24.3
+huggingface-hub==0.17.3
+scikit-learn==1.3.0