Add Qwen2-VL Amazon listing generator files

README.md

@@ -1,14 +1,73 @@
----
-title: Amazon Listing Generator
-emoji: 🦀
-colorFrom: pink
-colorTo: red
-sdk: gradio
-sdk_version: 5.43.1
-app_file: app.py
-pinned: false
-license: mit
-short_description: Generate listing attributes in one touch
+# 🛒 Qwen2-VL Amazon Listing Generator (LoRA)
+
+This Hugging Face Space showcases a **fine-tuned Qwen2-VL-7B model with LoRA adapter** trained to generate **Amazon-style product listings** from product images.
+
+## 🚀 Features
+
+- **Vision-Language Model**: Qwen2-VL-7B-Instruct with custom LoRA adapter
+- **Amazon Listing Generation**: Creates structured product listings with:
+  - Product title
+  - Bullet points (key features)
+  - Product description
+  - Keywords
+  - Product category
+- **CPU Optimized**: Runs on free CPU hardware (may take 1-2 minutes per generation)
+
+## 🔧 Model Details
+
+- **Base Model**: [Qwen/Qwen2-VL-7B-Instruct](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct)
+- **LoRA Adapter**: [soupstick/qwen2vl-amazon-ft-lora](https://huggingface.co/soupstick/qwen2vl-amazon-ft-lora)
+- **Fine-tuning**: Specialized for e-commerce product listing generation
+
+## 🎯 How to Use
+
+1. **Upload Image**: Click on the image upload area and select a product photo
+2. **Optional Prompt**: Modify the instruction if needed (default works well)
+3. **Generate**: Click "Generate Listing" and wait for results
+4. **Review Output**: Get structured Amazon-style listing in JSON format
+
+## 📋 Expected Output Format
+
+```json
+{
+  "title": "Product Title Here",
+  "bullet_points": [
+    "• Key feature 1",
+    "• Key feature 2",
+    "• Key feature 3"
+  ],
+  "description": "Detailed product description...",
+  "keywords": "relevant, product, keywords",
+  "category": "Product > Category > Subcategory"
+}
+```
+
+## ⚡ Performance Notes
+
+- **CPU Mode**: This demo runs on CPU hardware for free access
+- **Processing Time**: 1-2 minutes per generation due to CPU limitations
+- **Image Size**: Automatically resized to 512px for optimal performance
+- **Memory Optimized**: Uses float32 and low memory settings
+
+## 🔗 Links
+
+- [Model Repository](https://huggingface.co/soupstick/qwen2vl-amazon-ft-lora)
+- [Base Model](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct)
+- [Qwen2-VL Paper](https://arxiv.org/abs/2409.12191)
+
+## ⚠️ Limitations
+
+- **Demo Purpose**: This is a prototype for concept demonstration
+- **Accuracy**: Results depend on training data quality and model size
+- **Speed**: CPU inference is slower than GPU (upgrade hardware for faster results)
+- **Languages**: Primarily trained on English product descriptions
+
+## 🛠️ Technical Stack
+
+- **Framework**: Transformers, PEFT (LoRA), Gradio
+- **Model**: Qwen2-VL-7B with custom LoRA adapter on Unsloth-AI
+- **Hardware**: CPU-optimized for Hugging Face Spaces free tier
+
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+*Built with ❤️ using Hugging Face Spaces*

app.py

@@ -0,0 +1,197 @@
+import gradio as gr
+import torch
+import json
+from PIL import Image
+from transformers import AutoProcessor, Qwen2VLForConditionalGeneration
+from peft import PeftModel
+import warnings
+warnings.filterwarnings("ignore")
+
+# Model configuration
+BASE_MODEL = "Qwen/Qwen2-VL-7B-Instruct"
+ADAPTER = "soupstick/qwen2vl-amazon-ft-lora"
+
+# Global variables for lazy loading
+model = None
+processor = None
+
+def load_model():
+    """Load model and processor with CPU optimization"""
+    global model, processor
+    
+    if model is None:
+        print("⏳ Loading model (CPU mode)...")
+        try:
+            # Force CPU usage and optimize for memory
+            model = Qwen2VLForConditionalGeneration.from_pretrained(
+                BASE_MODEL,
+                device_map="cpu",
+                torch_dtype=torch.float32,  # Use float32 for CPU
+                trust_remote_code=True,
+                low_cpu_mem_usage=True,
+                use_cache=True
+            )
+            
+            # Load LoRA adapter
+            print("⏳ Loading LoRA adapter...")
+            model = PeftModel.from_pretrained(model, ADAPTER)
+            
+            # Load processor
+            processor = AutoProcessor.from_pretrained(
+                BASE_MODEL, 
+                trust_remote_code=True
+            )
+            
+            print("✅ Model loaded successfully!")
+            
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            return False
+    
+    return True
+
+def generate_listing(image, prompt="Generate Amazon listing."):
+    """Generate Amazon listing from image"""
+    
+    if image is None:
+        return "⚠️ Please upload an image."
+    
+    # Load model if not already loaded
+    if not load_model():
+        return "❌ Error: Could not load model. Please try again."
+    
+    try:
+        # Resize image to reduce memory usage
+        if image.size[0] > 512 or image.size[1] > 512:
+            image.thumbnail((512, 512), Image.Resampling.LANCZOS)
+        
+        # Prepare chat messages
+        messages = [{
+            "role": "user",
+            "content": [
+                {"type": "image", "image": image},
+                {"type": "text", "text": prompt}
+            ],
+        }]
+        
+        # Apply chat template
+        text = processor.apply_chat_template(
+            messages, 
+            tokenize=False, 
+            add_generation_prompt=True
+        )
+        
+        # Process inputs
+        inputs = processor(
+            text=text,
+            images=image,
+            return_tensors="pt"
+        )
+        
+        # Generate with conservative settings for CPU
+        print("⏳ Generating listing...")
+        with torch.no_grad():
+            generated_ids = model.generate(
+                **inputs,
+                max_new_tokens=256,  # Reduced for CPU
+                do_sample=True,
+                temperature=0.7,
+                top_p=0.8,
+                pad_token_id=processor.tokenizer.eos_token_id
+            )
+        
+        # Decode output
+        generated_ids_trimmed = [
+            out_ids[len(in_ids):] for in_ids, out_ids in zip(inputs.input_ids, generated_ids)
+        ]
+        
+        output_text = processor.batch_decode(
+            generated_ids_trimmed, 
+            skip_special_tokens=True, 
+            clean_up_tokenization_spaces=False
+        )[0]
+        
+        return output_text
+        
+    except Exception as e:
+        return f"❌ Error generating listing: {str(e)}"
+
+def format_example_output():
+    """Show example of expected output format"""
+    example = {
+        "title": "Premium Wireless Bluetooth Headphones with Noise Cancellation",
+        "bullet_points": [
+            "• Advanced noise cancellation technology for immersive audio experience",
+            "• 30-hour battery life with quick charge feature",
+            "• Premium comfort design with soft ear cushions",
+            "• Universal compatibility with all Bluetooth devices",
+            "• Built-in microphone for crystal clear calls"
+        ],
+        "description": "Experience premium audio quality with these advanced wireless headphones...",
+        "keywords": "wireless headphones, bluetooth, noise cancelling, premium audio",
+        "category": "Electronics > Audio > Headphones"
+    }
+    return json.dumps(example, indent=2)
+
+# Gradio Interface
+with gr.Blocks(theme=gr.themes.Soft(), title="Amazon Listing Generator") as demo:
+    gr.Markdown("""
+    # 🛒 Qwen2-VL Amazon Listing Generator (LoRA)
+    
+    Upload a product image and generate an Amazon-style listing with title, bullet points, description, keywords, and category.
+    
+    **Model**: [soupstick/qwen2vl-amazon-ft-lora](https://huggingface.co/soupstick/qwen2vl-amazon-ft-lora) (Qwen2-VL-7B + LoRA)
+    """)
+    
+    with gr.Row():
+        with gr.Column():
+            image_input = gr.Image(
+                type="pil", 
+                label="��� Upload Product Image",
+                height=300
+            )
+            prompt_input = gr.Textbox(
+                label="📝 Instruction (Optional)",
+                value="Generate Amazon listing.",
+                placeholder="Enter custom instruction or use default",
+                lines=2
+            )
+            generate_btn = gr.Button(
+                "🚀 Generate Listing", 
+                variant="primary",
+                size="lg"
+            )
+        
+        with gr.Column():
+            output_text = gr.Textbox(
+                label="📋 Generated Listing",
+                lines=15,
+                placeholder="Upload an image and click 'Generate Listing' to see results..."
+            )
+    
+    # Example section
+    with gr.Accordion("📋 Expected Output Format", open=False):
+        gr.Code(
+            format_example_output(),
+            language="json",
+            label="Example JSON Structure"
+        )
+    
+    # Event handler
+    generate_btn.click(
+        fn=generate_listing,
+        inputs=[image_input, prompt_input],
+        outputs=output_text
+    )
+    
+    # Footer
+    gr.Markdown("""
+    ---
+    **⚠️ Note**: This demo runs on CPU which may take 1-2 minutes per generation. 
+    For faster inference, consider upgrading to GPU hardware.
+    
+    **🔗 Links**: [Model Card](https://huggingface.co/soupstick/qwen2vl-amazon-ft-lora) | [Base Model](https://huggingface.co/Qwen/Qwen2-VL-7B-Instruct)
+    """)
+
+if __name__ == "__main__":
+    demo.queue().launch()

requirements.txt

@@ -0,0 +1,10 @@
+transformers>=4.44.0
+peft>=0.10.0
+accelerate>=0.24.0
+gradio>=4.0.0
+torch>=2.0.0
+torchvision>=0.15.0
+Pillow>=9.0.0
+numpy>=1.21.0
+requests>=2.25.0
+huggingface-hub>=0.17.0