Upload alt_tag_generator.py with huggingface_hub

alt_tag_generator.py

@@ -0,0 +1,300 @@
+"""
+AI-Powered Alt Tag Generator
+Complete accessibility tool for generating automatic alt tags from images
+"""
+
+import torch
+import time
+import warnings
+from io import BytesIO
+import requests
+from PIL import Image
+from transformers import BlipProcessor, BlipForConditionalGeneration
+from config import CONFIG, SUPPORTED_LANGUAGES
+
+warnings.filterwarnings("ignore")
+
+class AltTagGenerator:
+    """AI-powered alt tag generator using BLIP model"""
+    
+    def __init__(self, device='auto', verbose=True):
+        self.verbose = verbose
+        self.device = 'cuda' if torch.cuda.is_available() and device != 'cpu' else 'cpu'
+        
+        if self.verbose:
+            print(f"Initializing Alt Tag Generator on {self.device}")
+        
+        self.model_loaded = False
+        self._load_models()
+    
+    def _load_models(self):
+        """Load BLIP model and processor"""
+        try:
+            if self.verbose:
+                print("📥 Loading BLIP model...")
+            
+            self.processor = BlipProcessor.from_pretrained(
+                "Salesforce/blip-image-captioning-base",
+                cache_dir="./models"
+            )
+            
+            self.model = BlipForConditionalGeneration.from_pretrained(
+                "Salesforce/blip-image-captioning-base",
+                torch_dtype=torch.float16 if self.device == 'cuda' else torch.float32,
+                low_cpu_mem_usage=True,
+                cache_dir="./models"
+            )
+            
+            self.model = self.model.to(self.device)
+            self.model.eval()
+            self.model_loaded = True
+            
+            if self.verbose:
+                print("✅ BLIP model loaded successfully")
+                
+        except Exception as e:
+            print(f"❌ Error loading model: {e}")
+            self.model_loaded = False
+    
+    def load_image(self, image_source):
+        """Load image from URL, file path, or PIL Image"""
+        try:
+            if isinstance(image_source, str):
+                if image_source.startswith(('http://', 'https://')):
+                    response = requests.get(image_source, timeout=15)
+                    response.raise_for_status()
+                    image = Image.open(BytesIO(response.content))
+                else:
+                    image = Image.open(image_source)
+            else:
+                image = image_source
+            
+            image = image.convert('RGB')
+            
+            # Resize if too large
+            max_size = 800
+            if max(image.size) > max_size:
+                ratio = max_size / max(image.size)
+                new_size = tuple(int(dim * ratio) for dim in image.size)
+                image = image.resize(new_size, Image.Resampling.LANCZOS)
+            
+            return image
+            
+        except Exception as e:
+            raise Exception(f"Failed to load image: {e}")
+    
+    def generate_caption(self, image):
+        """Generate caption using BLIP model"""
+        if not self.model_loaded:
+            return {
+                'caption': 'Model not loaded',
+                'processing_time': 0.0,
+                'confidence': 0.0,
+                'error': 'Model failed to load'
+            }
+        
+        start_time = time.time()
+        
+        try:
+            if self.device == 'cuda':
+                torch.cuda.empty_cache()
+            
+            inputs = self.processor(image, return_tensors="pt")
+            inputs = {k: v.to(self.device) for k, v in inputs.items()}
+            
+            with torch.no_grad():
+                output = self.model.generate(
+                    **inputs,
+                    max_length=50,
+                    num_beams=4,
+                    early_stopping=True,
+                    do_sample=False,
+                    repetition_penalty=1.1,
+                    length_penalty=1.0
+                )
+            
+            caption = self.processor.decode(output[0], skip_special_tokens=True)
+            
+            del inputs, output
+            if self.device == 'cuda':
+                torch.cuda.empty_cache()
+            
+            processing_time = time.time() - start_time
+            
+            return {
+                'caption': caption,
+                'processing_time': processing_time,
+                'confidence': 0.85,
+                'error': None
+            }
+            
+        except Exception as e:
+            return {
+                'caption': 'Processing failed',
+                'processing_time': time.time() - start_time,
+                'confidence': 0.0,
+                'error': f'Error: {e}'
+            }
+    
+    def create_alt_variations(self, caption):
+        """Create different types of alt tags from caption"""
+        caption = caption.strip()
+        
+        if caption.lower().startswith('a '):
+            clean_caption = caption[2:]
+        elif caption.lower().startswith('an '):
+            clean_caption = caption[3:]
+        else:
+            clean_caption = caption
+        
+        words = clean_caption.split()
+        variations = {}
+        
+        # SHORT: 3-4 key words
+        if len(words) >= 3:
+            key_words = []
+            for word in words[:5]:
+                if word.lower() not in ['with', 'a', 'lot', 'of', 'the', 'and', 'or', 'in', 'on', 'at']:
+                    key_words.append(word)
+            variations['short'] = ' '.join(key_words[:3])
+        else:
+            variations['short'] = clean_caption
+        
+        # MEDIUM: 6-8 words
+        if len(words) <= 8:
+            variations['medium'] = clean_caption
+        else:
+            medium_words = words[:8]
+            for i in range(6, 8):
+                if i < len(words) and words[i].lower() in ['and', 'or', 'with', 'in', 'on', 'at']:
+                    medium_words = words[:i]
+                    break
+            variations['medium'] = ' '.join(medium_words)
+        
+        # LONG: Full caption
+        variations['long'] = clean_caption
+        
+        # ACCESSIBILITY: Optimized for screen readers
+        variations['accessibility'] = f"Image shows {clean_caption.lower()}"
+        
+        # SEO: Keywords only
+        stop_words = {'a', 'an', 'the', 'of', 'with', 'in', 'on', 'at', 'and', 'or', 'but', 'is', 'are'}
+        seo_words = [word for word in words if word.lower() not in stop_words]
+        variations['seo'] = ' '.join(seo_words[:6]).lower()
+        
+        # Clean up all variations
+        for key in variations:
+            variations[key] = variations[key].strip()
+            if not variations[key]:
+                variations[key] = 'Image'
+        
+        return variations
+    
+    def generate_alt_tags(self, image_source):
+        """Main method to generate comprehensive alt tags"""
+        total_start = time.time()
+        
+        if self.verbose:
+            print(f"🎯 Generating alt tags...")
+        
+        try:
+            image = self.load_image(image_source)
+            caption_result = self.generate_caption(image)
+            
+            if caption_result['error']:
+                raise Exception(caption_result['error'])
+            
+            alt_variations = self.create_alt_variations(caption_result['caption'])
+            total_time = time.time() - total_start
+            
+            results = {
+                'source': str(image_source),
+                'image_size': image.size,
+                'caption': caption_result['caption'],
+                'alt_tags': alt_variations,
+                'confidence': caption_result['confidence'],
+                'processing_time': {
+                    'caption': caption_result['processing_time'],
+                    'total': total_time
+                },
+                'device_used': self.device,
+                'model_info': {
+                    'name': 'BLIP Image Captioning',
+                    'version': 'base',
+                    'provider': 'Salesforce'
+                }
+            }
+            
+            if self.verbose:
+                print(f"✅ Alt tags generated in {total_time:.2f}s")
+            
+            return results
+            
+        except Exception as e:
+            return {
+                'error': str(e),
+                'alt_tags': {
+                    'short': 'Image',
+                    'medium': 'Image content unavailable',
+                    'long': 'Image content unavailable',
+                    'accessibility': 'Image: content unavailable',
+                    'seo': 'image'
+                },
+                'processing_time': {'total': time.time() - total_start},
+                'device_used': self.device
+            }
+    
+    def display_results(self, results):
+        """Display results in a formatted way"""
+        if 'error' in results:
+            print(f"❌ Error: {results['error']}")
+            return
+        
+        print(f"\nALT TAG RESULTS")
+        print("=" * 50)
+        print(f"Source: {results['source']}")
+        print(f"Size: {results['image_size']}")
+        print(f"Caption: {results['caption']}")
+        print(f"Device: {results['device_used']}")
+        print(f"Time: {results['processing_time']['total']:.2f}s")
+        print(f"Confidence: {results['confidence']:.2f}")
+        
+        print(f"\nALT TAG VARIATIONS:")
+        print("-" * 30)
+        for tag_type, alt_text in results['alt_tags'].items():
+            print(f"{tag_type.upper():>13}: {alt_text}")
+        print("=" * 50)
+
+def quick_demo():
+    """Quick demonstration of the alt tag generator"""
+    print("🎯 Quick Demo - AI Alt Tag Generator")
+    print("=" * 40)
+    
+    test_images = [
+        "https://images.unsplash.com/photo-1514888286974-6c03e2ca1dba?w=400",
+        "https://images.unsplash.com/photo-1546069901-ba9599a7e63c?w=400",
+    ]
+    
+    generator = AltTagGenerator()
+    
+    for i, image_url in enumerate(test_images, 1):
+        print(f"\n🖼️ Test Image {i}:")
+        print(f"URL: {image_url}")
+        
+        try:
+            results = generator.generate_alt_tags(image_url)
+            
+            if 'error' not in results:
+                print(f"✅ Caption: {results['caption']}")
+                print(f"⏱️ Time: {results['processing_time']['total']:.2f}s")
+                print(f"📝 Alt tags:")
+                for tag_type, alt_text in results['alt_tags'].items():
+                    print(f"   {tag_type}: {alt_text}")
+            else:
+                print(f"❌ Error: {results['error']}")
+                
+        except Exception as e:
+            print(f"❌ Exception: {e}")
+
+if __name__ == "__main__":
+    quick_demo()