Fix author

Initial commit- v 0.1

.gitignore

@@ -0,0 +1,37 @@
+# Python
+__pycache__/
+*.py[cod]
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+venv/
+env/
+
+# Models
+models/
+*.pth
+*.bin
+*.safetensors
+
+# Outputs
+outputs/
+cache/
+
+# IDE
+.vscode/
+.idea/
+.DS_Store
+
+# Logs
+*.log
+logs/
+
+# Environment
+.env
+
+extra/
+old_files/
+scripts/
+tests/

requirements.txt

@@ -0,0 +1,9 @@
+
+transformers==4.45.1
+diffusers==0.31.0
+accelerate==0.34.2
+safetensors==0.4.4
+peft>=0.11.0
+torch
+Pillow
+streamlit

src/app.py

@@ -0,0 +1,225 @@
+"""Pepe the Frog Meme Generator - Main Application"""
+
+import streamlit as st
+from PIL import Image
+import io
+from datetime import datetime
+
+# Import our modules
+from model.generator import PepeGenerator
+from model.config import ModelConfig
+from utils.image_processor import ImageProcessor
+
+# Page config
+st.set_page_config(
+    page_title="🐸 Pepe Meme Generator",
+    page_icon="🐸",
+    layout="wide",
+)
+
+# Custom CSS
+st.markdown("""
+    <style>
+    .stButton>button {
+        width: 100%;
+        background-color: #4CAF50;
+        color: white;
+        height: 3em;
+        border-radius: 10px;
+        font-weight: bold;
+    }
+    .stButton>button:hover {
+        background-color: #45a049;
+    }
+    </style>
+""", unsafe_allow_html=True)
+
+
+def init_session_state():
+    """Initialize session state"""
+    if 'generated_images' not in st.session_state:
+        st.session_state.generated_images = []
+    if 'generation_count' not in st.session_state:
+        st.session_state.generation_count = 0
+
+
+@st.cache_resource
+def load_generator():
+    """Load and cache the generator"""
+    return PepeGenerator()
+
+
+def get_example_prompts():
+    """Return example prompts"""
+    return [
+        "pepe the frog as a wizard casting spells",
+        "pepe the frog coding on a laptop",
+        "pepe the frog drinking coffee",
+        "pepe the frog as a superhero",
+        "pepe the frog reading a book",
+    ]
+
+
+def main():
+    """Main application"""
+    init_session_state()
+    
+    # Header
+    st.title("🐸 Pepe the Frog Meme Generator")
+    st.markdown("Create custom Pepe memes using AI! Powered by Stable Diffusion.")
+    
+    # Sidebar
+    st.sidebar.header("⚙️ Settings")
+    
+    # Style selection
+    style_options = {
+        "Default": "default",
+        "😊 Happy": "happy",
+        "😢 Sad": "sad",
+        "😏 Smug": "smug",
+        "😠 Angry": "angry",
+        "🤔 Thinking": "thinking",
+        "😲 Surprised": "surprised",
+    }
+    
+    selected_style = st.sidebar.selectbox(
+        "Choose Style",
+        list(style_options.keys())
+    )
+    style = style_options[selected_style]
+    
+    # Advanced settings
+    with st.sidebar.expander("🔧 Advanced Settings"):
+        steps = st.slider("Steps", 20, 100, 50, 5)
+        guidance = st.slider("Guidance Scale", 1.0, 20.0, 7.5, 0.5)
+        use_seed = st.checkbox("Fixed Seed")
+        seed = st.number_input("Seed", 0, 999999, 42) if use_seed else None
+    
+    # Text overlay settings
+    with st.sidebar.expander("💬 Add Text"):
+        add_text = st.checkbox("Add Meme Text")
+        top_text = st.text_input("Top Text") if add_text else ""
+        bottom_text = st.text_input("Bottom Text") if add_text else ""
+    
+    # Main area
+    col1, col2 = st.columns([1, 1])
+    
+    with col1:
+        st.subheader("✏️ Create Your Meme")
+        
+        # Prompt input
+        prompt = st.text_area(
+            "Describe your meme",
+            height=100,
+            placeholder="e.g., pepe the frog celebrating victory"
+        )
+        
+        # Examples
+        with st.expander("💡 Example Prompts"):
+            for example in get_example_prompts():
+                st.write(f"• {example}")
+        
+        # Generate button
+        col_btn1, col_btn2 = st.columns([3, 1])
+        with col_btn1:
+            generate = st.button("🎨 Generate Meme", type="primary")
+        with col_btn2:
+            num_vars = st.number_input("Variations", 1, 4, 1)
+    
+    with col2:
+        st.subheader("🖼️ Generated Meme")
+        placeholder = st.empty()
+        
+        if st.session_state.generated_images:
+            placeholder.image(
+                st.session_state.generated_images[-1],
+                use_container_width=True
+            )
+        else:
+            placeholder.info("Your meme will appear here...")
+    
+    # Generate
+    if generate and prompt:
+        try:
+            generator = load_generator()
+            
+            progress = st.progress(0)
+            status = st.empty()
+            
+            for i in range(num_vars):
+                status.text(f"Generating {i+1}/{num_vars}...")
+                progress.progress((i + 1) / num_vars)
+                
+                # Generate
+                image = generator.generate(
+                    prompt=prompt,
+                    style=style,
+                    num_inference_steps=steps,
+                    guidance_scale=guidance,
+                    seed=seed
+                )
+                
+                # Add text if requested
+                if add_text and (top_text or bottom_text):
+                    processor = ImageProcessor()
+                    image = processor.add_meme_text(image, top_text, bottom_text)
+                
+                st.session_state.generated_images.append(image)
+                st.session_state.generation_count += 1
+            
+            progress.empty()
+            status.empty()
+            
+            st.success("✅ Meme generated!")
+            
+            # Show result
+            if num_vars == 1:
+                placeholder.image(image, use_container_width=True)
+                
+                # Download
+                buf = io.BytesIO()
+                image.save(buf, format="PNG")
+                st.download_button(
+                    "⬇️ Download",
+                    buf.getvalue(),
+                    f"pepe_{datetime.now().strftime('%Y%m%d_%H%M%S')}.png",
+                    "image/png"
+                )
+            else:
+                st.subheader("All Variations")
+                cols = st.columns(min(num_vars, 2))
+                for idx, img in enumerate(st.session_state.generated_images[-num_vars:]):
+                    with cols[idx % 2]:
+                        st.image(img, use_container_width=True)
+        
+        except Exception as e:
+            st.error(f"Error: {str(e)}")
+    
+    elif generate and not prompt:
+        st.error("Please enter a prompt!")
+    
+    # Gallery
+    if st.session_state.generated_images:
+        st.divider()
+        with st.expander(f"🖼️ Gallery ({len(st.session_state.generated_images)} images)"):
+            cols = st.columns(4)
+            for idx, img in enumerate(reversed(st.session_state.generated_images[-8:])):
+                with cols[idx % 4]:
+                    st.image(img, use_container_width=True)
+    
+    # Footer
+    st.divider()
+    col_a, col_b, col_c = st.columns(3)
+    with col_a:
+        st.metric("Total Generated", st.session_state.generation_count)
+    with col_b:
+        st.metric("In Gallery", len(st.session_state.generated_images))
+    with col_c:
+        if st.button("🗑️ Clear"):
+            st.session_state.generated_images = []
+            st.session_state.generation_count = 0
+            st.rerun()
+
+
+if __name__ == "__main__":
+    main()

src/model/config.py

@@ -0,0 +1,35 @@
+"""Configuration management for the meme generator"""
+
+from dataclasses import dataclass
+from typing import Optional
+
+
+@dataclass
+class ModelConfig:
+    """Model configuration parameters"""
+    
+    # Model paths
+    BASE_MODEL: str = "runwayml/stable-diffusion-v1-5"
+    LORA_PATH: str = "./models/pepe_lora"
+    
+    # Default generation parameters
+    DEFAULT_STEPS: int = 50
+    DEFAULT_GUIDANCE: float = 7.5
+    DEFAULT_WIDTH: int = 512
+    DEFAULT_HEIGHT: int = 512
+    
+    # Negative prompt
+    DEFAULT_NEGATIVE_PROMPT: str = (
+        "blurry, low quality, distorted, deformed, "
+        "ugly, bad anatomy, watermark, signature"
+    )
+    
+    # Performance
+    ENABLE_ATTENTION_SLICING: bool = True
+    ENABLE_VAE_SLICING: bool = True
+    
+    # Available styles
+    AVAILABLE_STYLES: tuple = (
+        "default", "happy", "sad", "smug", 
+        "angry", "thinking", "surprised"
+    )

src/model/generator.py

@@ -0,0 +1,141 @@
+"""Pepe Meme Generator - Core generation logic"""
+
+from typing import Optional, List
+import torch
+from diffusers import StableDiffusionPipeline, DPMSolverMultistepScheduler
+import streamlit as st
+from PIL import Image
+import logging
+
+from .config import ModelConfig
+
+logger = logging.getLogger(__name__)
+
+
+class PepeGenerator:
+    """Main generator class for creating Pepe memes"""
+    
+    def __init__(self, config: Optional[ModelConfig] = None):
+        """Initialize the generator"""
+        self.config = config or ModelConfig()
+        self.device = self._get_device()
+        self.pipe = self._load_model()
+        logger.info(f"PepeGenerator initialized on {self.device}")
+    
+    @staticmethod
+    @st.cache_resource
+    def _load_model() -> StableDiffusionPipeline:
+        """Load and cache the Stable Diffusion model"""
+        logger.info("Loading Stable Diffusion model...")
+        
+        pipe = StableDiffusionPipeline.from_pretrained(
+            ModelConfig.BASE_MODEL,
+            torch_dtype=torch.float16,
+            safety_checker=None,
+        )
+        
+        # Optimize scheduler
+        pipe.scheduler = DPMSolverMultistepScheduler.from_config(
+            pipe.scheduler.config
+        )
+        
+        # Enable memory optimizations
+        pipe.enable_attention_slicing()
+        pipe.enable_vae_slicing()
+        
+        if torch.cuda.is_available():
+            pipe = pipe.to("cuda")
+            try:
+                pipe.enable_xformers_memory_efficient_attention()
+            except:
+                pass
+        
+        logger.info("Model loaded successfully")
+        return pipe
+    
+    @staticmethod
+    def _get_device() -> str:
+        """Determine the best available device"""
+        return "cuda" if torch.cuda.is_available() else "cpu"
+    
+    def generate(
+        self,
+        prompt: str,
+        style: str = "default",
+        negative_prompt: Optional[str] = None,
+        num_inference_steps: int = 50,
+        guidance_scale: float = 7.5,
+        seed: Optional[int] = None,
+        width: int = 512,
+        height: int = 512,
+    ) -> Image.Image:
+        """Generate a single Pepe meme image"""
+        
+        # Apply style preset
+        enhanced_prompt = self._apply_style_preset(prompt, style)
+        
+        # Set default negative prompt
+        if negative_prompt is None:
+            negative_prompt = self.config.DEFAULT_NEGATIVE_PROMPT
+        
+        # Set seed for reproducibility
+        generator = None
+        if seed is not None:
+            generator = torch.Generator(device=self.device).manual_seed(seed)
+        
+        logger.info(f"Generating: {enhanced_prompt[:50]}...")
+        
+        # Generate image
+        with torch.autocast(self.device):
+            output = self.pipe(
+                prompt=enhanced_prompt,
+                negative_prompt=negative_prompt,
+                num_inference_steps=num_inference_steps,
+                guidance_scale=guidance_scale,
+                generator=generator,
+                width=width,
+                height=height,
+            )
+        
+        return output.images[0]
+    
+    def generate_batch(
+        self,
+        prompt: str,
+        num_images: int = 4,
+        **kwargs
+    ) -> List[Image.Image]:
+        """Generate multiple variations"""
+        images = []
+        for i in range(num_images):
+            if 'seed' not in kwargs:
+                kwargs['seed'] = torch.randint(0, 100000, (1,)).item()
+            
+            image = self.generate(prompt, **kwargs)
+            images.append(image)
+            
+            if 'seed' in kwargs:
+                del kwargs['seed']
+        
+        return images
+    
+    @staticmethod
+    def _apply_style_preset(prompt: str, style: str) -> str:
+        """Apply style-specific prompt enhancements"""
+        style_modifiers = {
+            "happy": "cheerful, smiling, joyful",
+            "sad": "melancholic, crying, emotional",
+            "smug": "confident, satisfied, smirking",
+            "angry": "frustrated, mad, intense",
+            "thinking": "contemplative, philosophical",
+            "surprised": "shocked, amazed, wide eyes",
+        }
+        
+        base = f"pepe the frog, {prompt}"
+        
+        if style in style_modifiers:
+            base = f"{base}, {style_modifiers[style]}"
+        
+        base = f"{base}, high quality, detailed, meme art"
+        
+        return base

src/utils/image_processor.py

@@ -0,0 +1,91 @@
+"""Image processing utilities"""
+
+from PIL import Image, ImageDraw, ImageFont, ImageEnhance
+from typing import Optional, Tuple
+import logging
+
+logger = logging.getLogger(__name__)
+
+
+class ImageProcessor:
+    """Handles image post-processing"""
+    
+    @staticmethod
+    def add_meme_text(
+        image: Image.Image,
+        top_text: str = "",
+        bottom_text: str = "",
+        font_size: int = 40,
+        font_path: Optional[str] = None,
+    ) -> Image.Image:
+        """Add classic meme text to image"""
+        
+        img = image.copy()
+        draw = ImageDraw.Draw(img)
+        
+        # Load font
+        try:
+            if font_path:
+                font = ImageFont.truetype(font_path, font_size)
+            else:
+                font = ImageFont.truetype("impact.ttf", font_size)
+        except:
+            font = ImageFont.load_default()
+            logger.warning("Using default font")
+        
+        # Add top text
+        if top_text:
+            ImageProcessor._draw_text_with_outline(
+                draw, top_text.upper(), (img.width // 2, 30), font
+            )
+        
+        # Add bottom text
+        if bottom_text:
+            ImageProcessor._draw_text_with_outline(
+                draw, bottom_text.upper(), (img.width // 2, img.height - 50), font
+            )
+        
+        return img
+    
+    @staticmethod
+    def _draw_text_with_outline(
+        draw: ImageDraw.Draw,
+        text: str,
+        position: Tuple[int, int],
+        font: ImageFont.FreeTypeFont,
+        outline_width: int = 3,
+    ):
+        """Draw text with black outline"""
+        x, y = position
+        
+        # Draw outline
+        for adj_x in range(-outline_width, outline_width + 1):
+            for adj_y in range(-outline_width, outline_width + 1):
+                draw.text(
+                    (x + adj_x, y + adj_y),
+                    text,
+                    font=font,
+                    fill="black",
+                    anchor="mm"
+                )
+        
+        # Draw main text
+        draw.text(position, text, font=font, fill="white", anchor="mm")
+    
+    @staticmethod
+    def enhance_image(
+        image: Image.Image,
+        sharpness: float = 1.2,
+        contrast: float = 1.1,
+    ) -> Image.Image:
+        """Apply enhancement filters"""
+        
+        # Sharpen
+        enhancer = ImageEnhance.Sharpness(image)
+        image = enhancer.enhance(sharpness)
+        
+        # Adjust contrast
+        enhancer = ImageEnhance.Contrast(image)
+        image = enhancer.enhance(contrast)
+        
+        return image