Add dependencies for HuggingFace conversion and create test script

- Updated requirements.txt to include necessary packages for HuggingFace model conversion, including transformers, torch, and related libraries.
- Added a new test script (test_hf_conversion.py) to verify the functionality of HuggingFace conversion, including import tests, pipeline creation, and basic functionality with a sample image.

fast.py

@@ -2,88 +2,1108 @@ from fastapi import FastAPI, HTTPException, UploadFile, File
 from fastapi.responses import JSONResponse, HTMLResponse, PlainTextResponse
 from pydantic import BaseModel
 from typing import List, Optional
-import requests
 import json
-import base64
 from PIL import Image
 import io
-import os
 import time
 import uvicorn
+from transformers import AutoImageProcessor, AutoModelForObjectDetection, SwinModel, SwinConfig
+from transformers.pipelines import pipeline
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import torchvision.transforms as v2
+from huggingface_hub import PyTorchModelHubMixin
+import numpy as np
 
-app = FastAPI(title="Ollama Fashion Analyzer API", version="1.0.0")
+app = FastAPI(title="HuggingFace Fashion Analyzer API", version="1.0.0")
 
-class OllamaFashionAnalyzer:
-    def __init__(self, base_url=None):
-        """Initialize Ollama client"""
-        self.base_url = base_url or os.getenv("OLLAMA_BASE_URL", "http://localhost:11434")
-        self.model = "llava:7b"  # Using LLaVA for vision analysis
-    
-    def encode_image_from_bytes(self, image_bytes):
-        """Encode image bytes to base64 for Ollama"""
+# Fashion Image Encoder class for yainage90 model
+class ImageEncoder(nn.Module, PyTorchModelHubMixin):
+    def __init__(self, config):
+        super(ImageEncoder, self).__init__()
+        self.swin = SwinModel(config=config)
+        self.embedding_layer = nn.Linear(config.hidden_size, 128)
+
+    def forward(self, image_tensor):
+        features = self.swin(image_tensor).pooler_output
+        embeddings = self.embedding_layer(features)
+        embeddings = F.normalize(embeddings, p=2, dim=1)
+        return embeddings
+
+class HuggingFaceFashionAnalyzer:
+    def __init__(self):
+        """Initialize specialized fashion models from yainage90"""
+        print("Loading yainage90 fashion models...")
+
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+
+        # Initialize yainage90 fashion object detection model
+        try:
+            self.detection_ckpt = 'yainage90/fashion-object-detection'
+            self.detection_processor = AutoImageProcessor.from_pretrained(self.detection_ckpt)
+            self.detection_model = AutoModelForObjectDetection.from_pretrained(self.detection_ckpt).to(self.device)
+            print("Fashion object detection model loaded successfully")
+        except Exception as e:
+            print(f"Error loading fashion detection model: {e}")
+            self.detection_model = None
+            self.detection_processor = None
+
+        # Initialize yainage90 fashion feature extractor
+        try:
+            self.encoder_ckpt = "yainage90/fashion-image-feature-extractor"
+            self.encoder_config = SwinConfig.from_pretrained(self.encoder_ckpt)
+            self.encoder_image_processor = AutoImageProcessor.from_pretrained(self.encoder_ckpt)
+
+            # Create the encoder with proper configuration - use from_pretrained directly
+            self.feature_encoder = ImageEncoder.from_pretrained(self.encoder_ckpt).to(self.device)
+
+            # Setup image transforms for feature extraction
+            self.transform = v2.Compose([
+                v2.Resize((self.encoder_config.image_size, self.encoder_config.image_size)),
+                v2.ToTensor(),
+                v2.Normalize(mean=self.encoder_image_processor.image_mean, std=self.encoder_image_processor.image_std),
+            ])
+            print("Fashion feature extractor model loaded successfully")
+        except Exception as e:
+            print(f"Error loading fashion feature extractor: {e}")
+            self.feature_encoder = None
+            self.transform = None
+
+        # Initialize basic image captioning as fallback
+        try:
+            self.image_to_text = pipeline(
+                "image-to-text",
+                model="Salesforce/blip-image-captioning-base",
+                device=0 if torch.cuda.is_available() else -1
+            )
+            print("Basic image captioning model loaded successfully")
+        except Exception as e:
+            print(f"Error loading image captioning model: {e}")
+            self.image_to_text = None
+
+        # Fashion categories mapping
+        self.fashion_categories = {
+            0: 'bag', 1: 'bottom', 2: 'dress', 3: 'hat', 4: 'shoes', 5: 'outer', 6: 'top'
+        }
+
+    def process_image_from_bytes(self, image_bytes):
+        """Process image bytes and return PIL Image"""
         image = Image.open(io.BytesIO(image_bytes))
-        
+
         # Convert to RGB if necessary
         if image.mode != 'RGB':
             image = image.convert('RGB')
-        
-        # Convert to base64
-        buffered = io.BytesIO()
-        image.save(buffered, format="JPEG")
-        img_str = base64.b64encode(buffered.getvalue()).decode()
-        
-        return img_str
-    
+
+        return image
+
     def analyze_clothing_from_bytes(self, image_bytes):
-        """Detailed clothing analysis using Ollama from image bytes"""
-        
-        # Encode image
-        image_b64 = self.encode_image_from_bytes(image_bytes)
-        
-        # Fashion analysis prompt
-        prompt = """Analyze this clothing item in detail and provide information about:
-
-1. GARMENT TYPE: What type of clothing is this?
-2. COLORS: Primary and secondary colors
-3. COLLAR/NECKLINE: Style of collar or neckline
-4. SLEEVES: Sleeve type and length
-5. PATTERN: Any patterns or designs
-6. FIT: How does it fit (loose, fitted, etc.)
-7. MATERIAL: Apparent fabric type
-8. FEATURES: Buttons, pockets, zippers, etc.
-9. STYLE: Fashion style category
-10. OCCASION: Suitable occasions for wearing
-
-Be specific and detailed in your analysis."""
-        
-        # Make request to Ollama
-        payload = {
-            "model": self.model,
-            "prompt": prompt,
-            "images": [image_b64],
-            "stream": False,
-            "options": {
-                "temperature": 0.2,
-                "num_predict": 500
+        """Advanced fashion analysis using yainage90 specialized models"""
+
+        try:
+            # Process image
+            image = self.process_image_from_bytes(image_bytes)
+
+            # Get fashion object detection results
+            detection_results = self.detect_fashion_objects(image)
+
+            # Extract fashion features
+            fashion_features = self.extract_fashion_features(image)
+
+            # Get basic image description as fallback
+            basic_description = self.get_basic_description(image)
+
+            # Create comprehensive fashion analysis
+            analysis = self.create_advanced_fashion_analysis(detection_results, fashion_features, basic_description, image)
+
+            return analysis
+
+        except Exception as e:
+            return f"Error analyzing image: {str(e)}"
+
+    def detect_fashion_objects(self, image):
+        """Detect fashion objects using yainage90 fashion detection model"""
+        if self.detection_model is None or self.detection_processor is None:
+            return {"error": "Fashion detection model not available"}
+
+        try:
+            with torch.no_grad():
+                inputs = self.detection_processor(images=[image], return_tensors="pt")
+                outputs = self.detection_model(**inputs.to(self.device))
+                target_sizes = torch.tensor([[image.size[1], image.size[0]]])
+                results = self.detection_processor.post_process_object_detection(
+                    outputs, threshold=0.4, target_sizes=target_sizes
+                )[0]
+
+                detected_items = []
+                for score, label, box in zip(results["scores"], results["labels"], results["boxes"]):
+                    score = score.item()
+                    label = label.item()
+                    box = [i.item() for i in box]
+                    category = self.detection_model.config.id2label[label]
+                    detected_items.append({
+                        'category': category,
+                        'confidence': round(score, 3),
+                        'bbox': box
+                    })
+
+                return {"detected_items": detected_items}
+        except Exception as e:
+            return {"error": f"Detection failed: {str(e)}"}
+
+    def extract_fashion_features(self, image):
+        """Extract fashion features using yainage90 feature extractor"""
+        if self.feature_encoder is None or self.transform is None:
+            return {"error": "Feature extractor not available"}
+
+        try:
+            # Transform image for feature extraction
+            image_tensor = self.transform(image)
+
+            with torch.no_grad():
+                embedding = self.feature_encoder(image_tensor.unsqueeze(0).to(self.device))
+
+            return {
+                "feature_vector": embedding.cpu().numpy().tolist(),
+                "feature_dimension": embedding.shape[1]
             }
-        }
-        
+        except Exception as e:
+            return {"error": f"Feature extraction failed: {str(e)}"}
+
+    def get_basic_description(self, image):
+        """Get basic image description as fallback"""
+        if self.image_to_text is None:
+            return "Image analysis not available"
+
         try:
-            response = requests.post(
-                f"{self.base_url}/api/generate",
-                json=payload,
-                timeout=120  # Increased timeout for vision models
-            )
-            response.raise_for_status()
-            
-            result = response.json()
-            return result.get('response', 'No response received')
-            
-        except requests.exceptions.RequestException as e:
-            return f"Error: {str(e)}"
+            result = self.image_to_text(image)
+            # Convert result to list if it's a generator/iterator
+            if result is not None and hasattr(result, '__iter__') and not isinstance(result, (str, bytes)):
+                result_list = list(result)
+                if result_list and len(result_list) > 0:
+                    first_result = result_list[0]
+                    if isinstance(first_result, dict):
+                        return first_result.get('generated_text', 'Unable to describe image')
+            return "Unable to describe image"
+        except Exception as e:
+            return f"Description failed: {str(e)}"
+
+    def create_advanced_fashion_analysis(self, detection_results, fashion_features, basic_description, image):
+        """Create comprehensive fashion analysis using yainage90 model results"""
+
+        # Process detection results
+        detected_items = detection_results.get('detected_items', [])
+        detection_summary = self.summarize_detections(detected_items)
+
+        # Create comprehensive analysis
+        analysis_template = f"""🎽 ADVANCED FASHION ANALYSIS REPORT
+
+🔍 AI-POWERED OBJECT DETECTION:
+{detection_summary}
+
+📋 DETAILED GARMENT ANALYSIS:
+{self.create_detailed_garment_analysis(detected_items, basic_description)}
+
+🎨 STYLE & DESIGN ASSESSMENT:
+{self.create_style_assessment(detected_items, basic_description)}
+
+💡 PROFESSIONAL STYLING RECOMMENDATIONS:
+{self.generate_styling_recommendations(detected_items)}
+
+🔄 WARDROBE INTEGRATION ADVICE:
+{self.generate_wardrobe_advice(detected_items)}
+
+📊 FASHION SUMMARY:
+{self.create_fashion_summary(detected_items, basic_description)}
+
+🤖 TECHNICAL DETAILS:
+• Feature Vector Dimension: {fashion_features.get('feature_dimension', 'N/A')}
+• Detection Confidence: {self.get_average_confidence(detected_items)}
+• Analysis Method: yainage90 Fashion AI Models"""
+
+        return analysis_template
+
+    def summarize_detections(self, detected_items):
+        """Summarize detected fashion items"""
+        if not detected_items:
+            return "No specific fashion items detected. Using general image analysis."
+
+        summary_lines = []
+        for item in detected_items:
+            category = item['category'].upper()
+            confidence = item['confidence']
+            summary_lines.append(f"• {category}: {confidence*100:.1f}% confidence")
+
+        return "\n".join(summary_lines)
+
+    def create_detailed_garment_analysis(self, detected_items, basic_description):
+        """Create detailed analysis of detected garments"""
+        if not detected_items:
+            return f"Based on image analysis: {basic_description}\n" + self.extract_comprehensive_details(basic_description)
+
+        analysis_parts = []
+        for item in detected_items:
+            category = item['category']
+            confidence = item['confidence']
+
+            if confidence > 0.5:  # High confidence detections
+                analysis_parts.append(f"**{category.upper()}** (Confidence: {confidence*100:.1f}%)")
+                analysis_parts.append(self.get_category_specific_analysis(category, basic_description))
+                analysis_parts.append("")  # Add spacing
+
+        return "\n".join(analysis_parts)
+
+    def get_category_specific_analysis(self, category, description):
+        """Get specific analysis based on detected category"""
+        category_analyses = {
+            'top': self.analyze_top_garment(description),
+            'bottom': self.analyze_bottom_garment(description),
+            'dress': self.analyze_dress_garment(description),
+            'outer': self.analyze_outer_garment(description),
+            'shoes': self.analyze_shoes(description),
+            'bag': self.analyze_bag(description),
+            'hat': self.analyze_hat(description)
+        }
+
+        return category_analyses.get(category, f"General {category} analysis based on visual features.")
+
+    def analyze_top_garment(self, description):
+        """Analyze top garments (shirts, blouses, t-shirts)"""
+        analysis = []
+        desc_lower = description.lower()
+
+        # Determine specific type
+        if 't-shirt' in desc_lower or 'tee' in desc_lower:
+            analysis.append("• Type: T-shirt - casual wardrobe staple")
+            analysis.append("• Styling: Perfect for layering, casual wear, and relaxed occasions")
+        elif 'shirt' in desc_lower or 'blouse' in desc_lower:
+            analysis.append("• Type: Shirt/Blouse - versatile professional piece")
+            analysis.append("• Styling: Suitable for business casual, can be dressed up or down")
+        else:
+            analysis.append("• Type: Top garment - versatile upper body wear")
+
+        # Color analysis
+        colors = self.extract_colors(description)
+        analysis.append(f"• Color Profile: {colors}")
+
+        # Fit and style
+        fit = self.extract_fit(description)
+        analysis.append(f"• Fit & Silhouette: {fit}")
+
+        # Styling suggestions
+        analysis.append("• Styling Tips: Tuck into high-waisted bottoms, layer under jackets, or wear loose for casual looks")
+
+        return "\n".join(analysis)
+
+    def analyze_bottom_garment(self, description):
+        """Analyze bottom garments (pants, jeans, skirts)"""
+        analysis = []
+        desc_lower = description.lower()
+
+        if 'jeans' in desc_lower:
+            analysis.append("• Type: Jeans - denim casual essential")
+            analysis.append("• Material: Denim fabric, durable and versatile")
+        elif 'pants' in desc_lower or 'trousers' in desc_lower:
+            analysis.append("• Type: Pants/Trousers - structured bottom wear")
+            analysis.append("• Occasion: Professional, semi-formal, or smart casual")
+        elif 'skirt' in desc_lower:
+            analysis.append("• Type: Skirt - feminine silhouette piece")
+            analysis.append("• Style: Adds elegance and movement to outfits")
+        else:
+            analysis.append("• Type: Bottom garment - lower body wear")
+
+        fit = self.extract_fit(description)
+        analysis.append(f"• Fit & Cut: {fit}")
+
+        analysis.append("• Styling: Pair with fitted tops for balanced proportions")
+
+        return "\n".join(analysis)
+
+    def analyze_dress_garment(self, description):
+        """Analyze dress garments"""
+        analysis = []
+
+        analysis.append("• Type: Dress - complete outfit piece")
+        analysis.append("• Advantage: Single garment solution for put-together looks")
+
+        pattern = self.extract_pattern(description)
+        analysis.append(f"• Pattern & Design: {pattern}")
+
+        style = self.extract_style(description)
+        analysis.append(f"• Style Category: {style}")
+
+        occasion = self.extract_occasion(description)
+        analysis.append(f"• Best For: {occasion}")
+
+        analysis.append("• Styling: Add layers, accessories, or shoes to change the look's formality")
+
+        return "\n".join(analysis)
+
+    def analyze_outer_garment(self, description):
+        """Analyze outer garments (jackets, coats, blazers)"""
+        analysis = []
+        desc_lower = description.lower()
+
+        if 'blazer' in desc_lower:
+            analysis.append("• Type: Blazer - structured professional outerwear")
+            analysis.append("• Function: Adds polish and authority to outfits")
+        elif 'jacket' in desc_lower:
+            analysis.append("• Type: Jacket - versatile layering piece")
+            analysis.append("• Function: Provides warmth and style enhancement")
+        elif 'coat' in desc_lower:
+            analysis.append("• Type: Coat - substantial outerwear")
+            analysis.append("• Function: Weather protection with style")
+        else:
+            analysis.append("• Type: Outer garment - layering piece")
+
+        analysis.append("• Styling: Layer over various outfits to change formality level")
+        analysis.append("• Versatility: Essential for transitional weather and professional looks")
+
+        return "\n".join(analysis)
+
+    def analyze_shoes(self, description):
+        """Analyze footwear"""
+        analysis = []
+        analysis.append("• Type: Footwear - outfit foundation piece")
+        analysis.append("• Impact: Significantly influences overall look formality and style")
+        analysis.append("• Styling: Choose based on occasion, comfort needs, and outfit balance")
+        analysis.append("• Tip: Quality footwear elevates any outfit")
+
+        return "\n".join(analysis)
+
+    def analyze_bag(self, description):
+        """Analyze bags and accessories"""
+        analysis = []
+        analysis.append("• Type: Bag/Accessory - functional style element")
+        analysis.append("• Purpose: Combines practicality with fashion statement")
+        analysis.append("• Styling: Should complement outfit colors and formality level")
+        analysis.append("• Tip: Quality bags are investment pieces that enhance multiple outfits")
+
+        return "\n".join(analysis)
+
+    def analyze_hat(self, description):
+        """Analyze hats and headwear"""
+        analysis = []
+        analysis.append("• Type: Hat/Headwear - statement accessory")
+        analysis.append("• Function: Adds personality and can change outfit's entire vibe")
+        analysis.append("• Styling: Consider face shape, hair style, and occasion")
+        analysis.append("• Tip: Hats can make simple outfits more interesting and unique")
+
+        return "\n".join(analysis)
+
+    def create_style_assessment(self, detected_items, basic_description):
+        """Create style assessment based on detected items"""
+        if not detected_items:
+            return self.extract_style(basic_description)
+
+        style_elements = []
+        categories = [item['category'] for item in detected_items if item['confidence'] > 0.5]
+
+        if 'dress' in categories:
+            style_elements.append("• Feminine and elegant aesthetic")
+            style_elements.append("• Single-piece sophistication")
+
+        if 'blazer' in categories or 'outer' in categories:
+            style_elements.append("• Professional and structured elements")
+            style_elements.append("• Layered sophistication")
+
+        if 'jeans' in basic_description.lower() or 'bottom' in categories:
+            style_elements.append("• Casual and approachable foundation")
+            style_elements.append("• Versatile everyday appeal")
+
+        if not style_elements:
+            style_elements.append("• Contemporary fashion sensibility")
+            style_elements.append("• Versatile styling potential")
+
+        return "\n".join(style_elements)
+
+    def generate_styling_recommendations(self, detected_items):
+        """Generate styling recommendations based on detected items"""
+        if not detected_items:
+            return "• Focus on fit, color coordination, and occasion appropriateness\n• Layer pieces to create visual interest\n• Accessorize to personalize the look"
+
+        recommendations = []
+        categories = [item['category'] for item in detected_items if item['confidence'] > 0.5]
+
+        if 'top' in categories:
+            recommendations.append("• Tuck into high-waisted bottoms for a polished silhouette")
+            recommendations.append("• Layer under jackets or cardigans for depth")
+
+        if 'bottom' in categories:
+            recommendations.append("• Pair with fitted tops to balance proportions")
+            recommendations.append("• Choose shoes that complement the formality level")
+
+        if 'dress' in categories:
+            recommendations.append("• Add a belt to define the waist")
+            recommendations.append("• Layer with jackets or cardigans for versatility")
+            recommendations.append("• Change accessories to shift from day to night")
+
+        if 'outer' in categories:
+            recommendations.append("• Use as a statement piece over simple outfits")
+            recommendations.append("• Ensure proper fit in shoulders and sleeves")
+
+        if not recommendations:
+            recommendations.append("• Focus on color harmony and proportion balance")
+            recommendations.append("• Consider the occasion and dress code")
+
+        return "\n".join(recommendations)
+
+    def generate_wardrobe_advice(self, detected_items):
+        """Generate wardrobe integration advice"""
+        if not detected_items:
+            return "• Invest in versatile, quality basics\n• Build around neutral colors\n• Choose pieces that work for multiple occasions"
+
+        advice = []
+        categories = [item['category'] for item in detected_items if item['confidence'] > 0.5]
+
+        if 'top' in categories:
+            advice.append("• Essential wardrobe building block")
+            advice.append("• Pairs well with multiple bottom styles")
+
+        if 'bottom' in categories:
+            advice.append("• Foundation piece for outfit construction")
+            advice.append("• Invest in quality fit and classic styles")
+
+        if 'dress' in categories:
+            advice.append("• Versatile one-piece solution")
+            advice.append("• Can be styled for multiple occasions")
+
+        if 'outer' in categories:
+            advice.append("• Transforms and elevates basic outfits")
+            advice.append("• Essential for professional wardrobes")
+
+        advice.append("• Consider cost-per-wear when building wardrobe")
+        advice.append("• Focus on pieces that reflect your lifestyle needs")
+
+        return "\n".join(advice)
+
+    def create_fashion_summary(self, detected_items, basic_description):
+        """Create comprehensive fashion summary"""
+        if not detected_items:
+            return f"This garment demonstrates contemporary design with versatile styling potential. {basic_description}"
+
+        primary_items = [item for item in detected_items if item['confidence'] > 0.6]
+
+        if primary_items:
+            main_category = primary_items[0]['category']
+            confidence = primary_items[0]['confidence']
+
+            summary = f"This {main_category} demonstrates {confidence*100:.0f}% detection confidence with professional fashion AI analysis. "
+
+            if main_category in ['dress']:
+                summary += "Offers complete outfit solution with feminine appeal and versatile styling options."
+            elif main_category in ['top', 'shirt', 'blouse']:
+                summary += "Serves as essential wardrobe foundation with excellent layering and styling flexibility."
+            elif main_category in ['bottom', 'pants', 'jeans']:
+                summary += "Provides structural foundation for balanced outfit proportions and professional styling."
+            elif main_category in ['outer', 'jacket', 'blazer']:
+                summary += "Functions as transformative layering piece that elevates casual outfits to professional standards."
+            else:
+                summary += "Represents quality fashion piece with contemporary appeal and styling versatility."
+        else:
+            summary = "Fashion analysis indicates contemporary styling with good versatility potential."
+
+        return summary
+
+    def get_average_confidence(self, detected_items):
+        """Calculate average detection confidence"""
+        if not detected_items:
+            return "N/A"
+
+        confidences = [item['confidence'] for item in detected_items]
+        avg_confidence = sum(confidences) / len(confidences)
+        return f"{avg_confidence*100:.1f}%"
+
+    def extract_comprehensive_details(self, description):
+        """Extract comprehensive details from description"""
+        details = []
+        details.append(f"• Garment Type: {self.extract_garment_type(description)}")
+        details.append(f"• Color Analysis: {self.extract_colors(description)}")
+        details.append(f"• Pattern & Design: {self.extract_pattern(description)}")
+        details.append(f"• Style Category: {self.extract_style(description)}")
+        details.append(f"• Occasion Suitability: {self.extract_occasion(description)}")
+
+        return "\n".join(details)
+
+    def clean_generated_text(self, text):
+        """Clean and format generated text for better readability"""
+        if not text:
+            return ""
+
+        # Remove common artifacts and improve formatting
+        text = text.strip()
+
+        # Remove repetitive phrases
+        lines = text.split('\n')
+        cleaned_lines = []
+        seen_lines = set()
+
+        for line in lines:
+            line = line.strip()
+            if line and line not in seen_lines and len(line) > 10:
+                cleaned_lines.append(line)
+                seen_lines.add(line)
+
+        return '\n'.join(cleaned_lines[:5])  # Limit to 5 unique lines
+
+    def generate_advanced_insights(self, description):
+        """Generate sophisticated fashion insights when AI generation fails"""
+        garment_type = self.extract_garment_type(description).lower()
+        colors = self.extract_colors(description).lower()
+        pattern = self.extract_pattern(description).lower()
+        style = self.extract_style(description).lower()
+
+        insights = []
+
+        # Advanced garment-specific insights
+        if 'dress' in garment_type:
+            if 'floral' in pattern:
+                insights.extend([
+                    "This floral dress exemplifies the timeless appeal of botanical motifs in women's fashion.",
+                    "The floral pattern creates visual movement and adds romantic femininity to the silhouette.",
+                    "Ideal for transitional seasons and outdoor social events where natural beauty is celebrated."
+                ])
+            elif 'black' in colors:
+                insights.extend([
+                    "The classic black dress represents the epitome of versatile elegance in fashion.",
+                    "This piece serves as a foundational wardrobe element with endless styling possibilities.",
+                    "Perfect for day-to-night transitions with simple accessory changes."
+                ])
+            else:
+                insights.extend([
+                    "This dress demonstrates contemporary design principles with classic appeal.",
+                    "The silhouette offers both comfort and sophisticated style for modern lifestyles."
+                ])
+        elif any(item in garment_type for item in ['shirt', 'blouse', 'top']):
+            insights.extend([
+                "This top represents a versatile foundation piece essential for capsule wardrobes.",
+                "The design allows for multiple styling interpretations from casual to professional.",
+                "Perfect for layering strategies and seasonal wardrobe transitions."
+            ])
+        elif any(item in garment_type for item in ['pants', 'jeans', 'trousers']):
+            insights.extend([
+                "These bottoms provide structural foundation for balanced outfit proportions.",
+                "The cut and fit demonstrate attention to contemporary silhouette preferences.",
+                "Suitable for building cohesive looks across casual and semi-formal contexts."
+            ])
+
+        # Add sophisticated pattern and color insights
+        if 'floral' in pattern:
+            insights.append("The botanical motif connects the wearer to nature-inspired fashion trends and seasonal styling.")
+        elif 'solid' in pattern:
+            insights.append("The solid construction maximizes styling versatility and accessory compatibility.")
+        elif 'striped' in pattern:
+            insights.append("The linear pattern creates visual interest while maintaining classic appeal.")
+
+        # Add color psychology insights
+        if 'black' in colors:
+            insights.append("Black conveys sophistication, authority, and timeless elegance in fashion psychology.")
+        elif 'white' in colors:
+            insights.append("White represents purity, freshness, and minimalist aesthetic principles.")
+        elif any(color in colors for color in ['blue', 'navy']):
+            insights.append("Blue tones suggest reliability, professionalism, and calming visual impact.")
+        elif any(color in colors for color in ['red', 'burgundy']):
+            insights.append("Red spectrum colors project confidence, energy, and bold fashion statements.")
+
+        return ' '.join(insights) if insights else "This garment demonstrates thoughtful design principles with contemporary market appeal and versatile styling potential."
+
+    def generate_fallback_insights(self, description):
+        """Generate fallback insights when AI text generation fails"""
+        garment_type = self.extract_garment_type(description).lower()
+        pattern = self.extract_pattern(description).lower()
+
+        insights = []
+
+        if 'dress' in garment_type:
+            if 'floral' in pattern:
+                insights.extend([
+                    "This floral dress embodies feminine elegance and seasonal charm.",
+                    "The floral pattern adds visual interest and romantic appeal.",
+                    "Perfect for spring/summer occasions and outdoor events."
+                ])
+            else:
+                insights.extend([
+                    "This dress offers versatile styling options for various occasions.",
+                    "The silhouette provides both comfort and style."
+                ])
+        elif any(item in garment_type for item in ['shirt', 'blouse']):
+            insights.extend([
+                "This top serves as a versatile wardrobe foundation piece.",
+                "Can be styled up or down depending on the occasion."
+            ])
+        elif any(item in garment_type for item in ['pants', 'jeans']):
+            insights.extend([
+                "These bottoms provide a solid foundation for outfit building.",
+                "Suitable for both casual and semi-formal styling."
+            ])
+
+        # Add pattern-specific insights
+        if 'floral' in pattern:
+            insights.append("The floral motif brings natural beauty and femininity to the design.")
+        elif 'solid' in pattern:
+            insights.append("The solid color provides versatility for accessorizing and layering.")
+
+        return ' '.join(insights) if insights else "This garment demonstrates classic design principles with contemporary appeal."
+
+    def extract_garment_type(self, description):
+        """Extract garment type from description with enhanced detection"""
+        garment_keywords = {
+            'dress': 'Dress',
+            'gown': 'Evening Gown',
+            'shirt': 'Shirt/Blouse',
+            'blouse': 'Blouse',
+            'top': 'Top',
+            't-shirt': 'T-Shirt',
+            'tank': 'Tank Top',
+            'camisole': 'Camisole',
+            'pants': 'Pants/Trousers',
+            'trousers': 'Trousers',
+            'jeans': 'Jeans',
+            'leggings': 'Leggings',
+            'jacket': 'Jacket',
+            'blazer': 'Blazer',
+            'coat': 'Coat',
+            'cardigan': 'Cardigan',
+            'sweater': 'Sweater',
+            'pullover': 'Pullover',
+            'hoodie': 'Hoodie',
+            'sweatshirt': 'Sweatshirt',
+            'skirt': 'Skirt',
+            'shorts': 'Shorts',
+            'jumpsuit': 'Jumpsuit',
+            'romper': 'Romper',
+            'vest': 'Vest',
+            'tunic': 'Tunic'
+        }
+
+        description_lower = description.lower()
+
+        # Check for specific garment types first
+        for keyword, garment_type in garment_keywords.items():
+            if keyword in description_lower:
+                return garment_type
+
+        # Fallback analysis based on context clues
+        if any(word in description_lower for word in ['wearing', 'outfit', 'clothing']):
+            return "Fashion Garment"
+
+        return "Clothing Item"
+
+    def extract_colors(self, description):
+        """Extract colors from description with enhanced detection and color theory analysis"""
+        color_keywords = {
+            'black': {'name': 'Black', 'category': 'neutral', 'season': 'all', 'formality': 'high'},
+            'white': {'name': 'White', 'category': 'neutral', 'season': 'all', 'formality': 'high'},
+            'blue': {'name': 'Blue', 'category': 'cool', 'season': 'all', 'formality': 'medium'},
+            'navy': {'name': 'Navy Blue', 'category': 'neutral', 'season': 'all', 'formality': 'high'},
+            'red': {'name': 'Red', 'category': 'warm', 'season': 'winter', 'formality': 'medium'},
+            'green': {'name': 'Green', 'category': 'cool', 'season': 'spring', 'formality': 'medium'},
+            'yellow': {'name': 'Yellow', 'category': 'warm', 'season': 'summer', 'formality': 'low'},
+            'pink': {'name': 'Pink', 'category': 'warm', 'season': 'spring', 'formality': 'low'},
+            'purple': {'name': 'Purple', 'category': 'cool', 'season': 'fall', 'formality': 'medium'},
+            'brown': {'name': 'Brown', 'category': 'neutral', 'season': 'fall', 'formality': 'medium'},
+            'gray': {'name': 'Gray', 'category': 'neutral', 'season': 'all', 'formality': 'high'},
+            'grey': {'name': 'Gray', 'category': 'neutral', 'season': 'all', 'formality': 'high'},
+            'orange': {'name': 'Orange', 'category': 'warm', 'season': 'fall', 'formality': 'low'},
+            'beige': {'name': 'Beige', 'category': 'neutral', 'season': 'all', 'formality': 'medium'},
+            'cream': {'name': 'Cream', 'category': 'neutral', 'season': 'spring', 'formality': 'medium'},
+            'tan': {'name': 'Tan', 'category': 'neutral', 'season': 'summer', 'formality': 'medium'},
+            'gold': {'name': 'Gold', 'category': 'warm', 'season': 'fall', 'formality': 'high'},
+            'silver': {'name': 'Silver', 'category': 'cool', 'season': 'winter', 'formality': 'high'},
+            'maroon': {'name': 'Maroon', 'category': 'warm', 'season': 'fall', 'formality': 'high'},
+            'burgundy': {'name': 'Burgundy', 'category': 'warm', 'season': 'fall', 'formality': 'high'},
+            'teal': {'name': 'Teal', 'category': 'cool', 'season': 'winter', 'formality': 'medium'},
+            'turquoise': {'name': 'Turquoise', 'category': 'cool', 'season': 'summer', 'formality': 'low'},
+            'coral': {'name': 'Coral', 'category': 'warm', 'season': 'summer', 'formality': 'low'},
+            'mint': {'name': 'Mint', 'category': 'cool', 'season': 'spring', 'formality': 'low'},
+            'lavender': {'name': 'Lavender', 'category': 'cool', 'season': 'spring', 'formality': 'low'}
+        }
+
+        description_lower = description.lower()
+        found_colors = []
+
+        for keyword, color_info in color_keywords.items():
+            if keyword in description_lower:
+                if color_info not in found_colors:  # Avoid duplicates
+                    found_colors.append(color_info)
+
+        if found_colors:
+            primary_color = found_colors[0]
+            color_analysis = []
+
+            # Primary color analysis
+            color_analysis.append(f"Primary: {primary_color['name']}")
+
+            # Color theory insights
+            if primary_color['category'] == 'neutral':
+                color_analysis.append("(Neutral - highly versatile)")
+            elif primary_color['category'] == 'warm':
+                color_analysis.append("(Warm tone - energetic and approachable)")
+            else:
+                color_analysis.append("(Cool tone - calming and professional)")
+
+            # Seasonal and styling context
+            if primary_color['season'] != 'all':
+                color_analysis.append(f"Best for {primary_color['season']} styling")
+
+            # Formality level
+            if primary_color['formality'] == 'high':
+                color_analysis.append("Suitable for formal occasions")
+            elif primary_color['formality'] == 'medium':
+                color_analysis.append("Versatile for casual to semi-formal")
+            else:
+                color_analysis.append("Perfect for casual, relaxed styling")
+
+            # Additional colors
+            if len(found_colors) > 1:
+                other_colors = [c['name'] for c in found_colors[1:]]
+                color_analysis.append(f"Secondary: {', '.join(other_colors)}")
+
+            return ' • '.join(color_analysis)
+        else:
+            # Try to infer from context
+            if any(word in description_lower for word in ['dark', 'deep']):
+                return "Dark tones detected • Creates sophisticated, slimming effect • Suitable for formal occasions"
+            elif any(word in description_lower for word in ['light', 'pale', 'bright']):
+                return "Light/bright tones detected • Fresh, youthful appearance • Perfect for casual, daytime wear"
+            else:
+                return "Mixed color palette • Offers styling versatility • Consider color coordination principles"
+
+    def extract_neckline(self, description):
+        """Extract neckline information with intelligent inference"""
+        description_lower = description.lower()
+
+        # Direct detection
+        neckline_keywords = {
+            'v-neck': 'V-neckline',
+            'scoop': 'Scoop neckline',
+            'crew': 'Crew neckline',
+            'round': 'Round neckline',
+            'collar': 'Collared',
+            'turtleneck': 'Turtleneck',
+            'off-shoulder': 'Off-shoulder',
+            'strapless': 'Strapless',
+            'halter': 'Halter neckline'
+        }
+
+        for keyword, neckline_type in neckline_keywords.items():
+            if keyword in description_lower:
+                return neckline_type
+
+        # Intelligent inference based on garment type
+        if 'dress' in description_lower:
+            if 'formal' in description_lower or 'evening' in description_lower:
+                return "Likely elegant neckline (common for dresses)"
+            else:
+                return "Standard dress neckline (round or scoop typical)"
+        elif any(word in description_lower for word in ['shirt', 'blouse']):
+            return "Standard shirt collar or neckline"
+        elif 't-shirt' in description_lower:
+            return "Crew or round neckline (typical for t-shirts)"
+
+        return "Neckline present but style not specified"
+
+    def extract_sleeves(self, description):
+        """Extract sleeve information with intelligent inference"""
+        description_lower = description.lower()
+
+        # Direct detection
+        sleeve_keywords = {
+            'long sleeve': 'Long sleeves',
+            'short sleeve': 'Short sleeves',
+            'sleeveless': 'Sleeveless',
+            'cap sleeve': 'Cap sleeves',
+            'three-quarter': '3/4 sleeves',
+            'bell sleeve': 'Bell sleeves',
+            'puff sleeve': 'Puff sleeves'
+        }
+
+        for keyword, sleeve_type in sleeve_keywords.items():
+            if keyword in description_lower:
+                return sleeve_type
+
+        # Intelligent inference based on garment type
+        if 'dress' in description_lower:
+            if 'summer' in description_lower or 'floral' in description_lower:
+                return "Likely short sleeves or sleeveless (common for summer/floral dresses)"
+            elif 'winter' in description_lower or 'formal' in description_lower:
+                return "Likely long sleeves (common for formal/winter dresses)"
+            else:
+                return "Sleeve style varies (short sleeves, sleeveless, or straps typical for dresses)"
+        elif 't-shirt' in description_lower:
+            return "Short sleeves (standard for t-shirts)"
+        elif any(word in description_lower for word in ['jacket', 'blazer', 'coat']):
+            return "Long sleeves (standard for outerwear)"
+        elif any(word in description_lower for word in ['tank', 'camisole']):
+            return "Sleeveless or thin straps"
+
+        return "Sleeve style not specified in description"
+
+    def extract_pattern(self, description):
+        """Extract pattern information with enhanced detection"""
+        pattern_keywords = {
+            'floral': 'Floral print',
+            'flower': 'Floral design',
+            'striped': 'Striped pattern',
+            'stripes': 'Striped pattern',
+            'plaid': 'Plaid pattern',
+            'checkered': 'Checkered pattern',
+            'polka dot': 'Polka dot pattern',
+            'dots': 'Dotted pattern',
+            'geometric': 'Geometric pattern',
+            'abstract': 'Abstract pattern',
+            'paisley': 'Paisley pattern',
+            'animal print': 'Animal print',
+            'leopard': 'Leopard print',
+            'zebra': 'Zebra print',
+            'solid': 'Solid color',
+            'plain': 'Plain/solid',
+            'printed': 'Printed design',
+            'embroidered': 'Embroidered details',
+            'lace': 'Lace pattern',
+            'textured': 'Textured fabric'
+        }
+
+        description_lower = description.lower()
+        found_patterns = []
+
+        for keyword, pattern_name in pattern_keywords.items():
+            if keyword in description_lower:
+                if pattern_name not in found_patterns:
+                    found_patterns.append(pattern_name)
+
+        if found_patterns:
+            return ', '.join(found_patterns)
+        else:
+            # Try to infer from context
+            if any(word in description_lower for word in ['print', 'design', 'pattern']):
+                return "Decorative pattern present"
+            else:
+                return "Solid or minimal pattern"
+
+    def extract_fit(self, description):
+        """Extract fit information with intelligent inference"""
+        description_lower = description.lower()
+
+        # Direct detection
+        fit_keywords = {
+            'loose': 'Loose fit',
+            'tight': 'Tight/fitted',
+            'fitted': 'Fitted',
+            'oversized': 'Oversized',
+            'slim': 'Slim fit',
+            'relaxed': 'Relaxed fit',
+            'bodycon': 'Body-conscious fit',
+            'a-line': 'A-line silhouette',
+            'straight': 'Straight fit'
+        }
+
+        for keyword, fit_type in fit_keywords.items():
+            if keyword in description_lower:
+                return fit_type
+
+        # Intelligent inference based on garment type and style
+        if 'dress' in description_lower:
+            if 'floral' in description_lower:
+                return "Likely flowing or A-line fit (common for floral dresses)"
+            elif 'formal' in description_lower:
+                return "Likely fitted or tailored silhouette"
+            else:
+                return "Dress silhouette (fit varies by style)"
+        elif any(word in description_lower for word in ['jeans', 'pants']):
+            return "Standard trouser fit (straight, slim, or relaxed)"
+        elif any(word in description_lower for word in ['blazer', 'jacket']):
+            return "Tailored fit (structured silhouette)"
+        elif 't-shirt' in description_lower:
+            return "Regular fit (standard t-shirt silhouette)"
+
+        return "Fit style not specified in description"
+
+    def extract_material(self, description):
+        """Extract material information with intelligent inference"""
+        description_lower = description.lower()
+
+        # Direct detection
+        material_keywords = {
+            'cotton': 'Cotton',
+            'denim': 'Denim',
+            'silk': 'Silk',
+            'wool': 'Wool',
+            'polyester': 'Polyester',
+            'leather': 'Leather',
+            'linen': 'Linen',
+            'chiffon': 'Chiffon',
+            'satin': 'Satin',
+            'velvet': 'Velvet',
+            'lace': 'Lace',
+            'knit': 'Knit fabric',
+            'jersey': 'Jersey',
+            'tweed': 'Tweed'
+        }
+
+        found_materials = []
+        for keyword, material_name in material_keywords.items():
+            if keyword in description_lower:
+                found_materials.append(material_name)
+
+        if found_materials:
+            return ', '.join(found_materials)
+
+        # Intelligent inference based on garment type
+        if 'dress' in description_lower:
+            if 'floral' in description_lower:
+                return "Likely lightweight fabric (cotton, chiffon, or jersey common for floral dresses)"
+            elif 'formal' in description_lower:
+                return "Likely elegant fabric (silk, satin, or crepe)"
+            else:
+                return "Dress fabric (varies by style and season)"
+        elif 'jeans' in description_lower:
+            return "Denim (standard for jeans)"
+        elif 't-shirt' in description_lower:
+            return "Cotton or cotton blend (typical for t-shirts)"
+        elif any(word in description_lower for word in ['blazer', 'suit']):
+            return "Structured fabric (wool, polyester blend, or cotton)"
+        elif 'sweater' in description_lower:
+            return "Knit fabric (wool, cotton, or synthetic blend)"
+
+        return "Fabric type not specified in description"
+
+    def extract_features(self, description):
+        """Extract features information"""
+        feature_keywords = ['button', 'zip', 'pocket', 'belt', 'hood']
+        description_lower = description.lower()
+        found_features = [feature for feature in feature_keywords if feature in description_lower]
+        return ', '.join(found_features).title() if found_features else "Specific features not clearly visible"
+
+    def extract_style(self, description):
+        """Extract style information with intelligent inference"""
+        description_lower = description.lower()
+
+        # Direct detection
+        style_keywords = {
+            'casual': 'Casual',
+            'formal': 'Formal',
+            'business': 'Business/Professional',
+            'sporty': 'Sporty/Athletic',
+            'elegant': 'Elegant',
+            'vintage': 'Vintage',
+            'bohemian': 'Bohemian',
+            'minimalist': 'Minimalist',
+            'romantic': 'Romantic',
+            'edgy': 'Edgy',
+            'classic': 'Classic',
+            'trendy': 'Trendy/Contemporary'
+        }
+
+        found_styles = []
+        for keyword, style_name in style_keywords.items():
+            if keyword in description_lower:
+                found_styles.append(style_name)
+
+        if found_styles:
+            return ', '.join(found_styles)
+
+        # Intelligent inference based on garment type and patterns
+        if 'dress' in description_lower:
+            if 'floral' in description_lower:
+                return "Feminine/Romantic (floral dresses often have romantic appeal)"
+            elif 'black' in description_lower:
+                return "Classic/Versatile (black dresses are wardrobe staples)"
+            else:
+                return "Feminine/Versatile (dresses suit various style preferences)"
+        elif any(word in description_lower for word in ['blazer', 'suit']):
+            return "Professional/Business (structured formal wear)"
+        elif 'jeans' in description_lower:
+            return "Casual/Everyday (denim is casual staple)"
+        elif 't-shirt' in description_lower:
+            return "Casual/Relaxed (t-shirts are casual basics)"
+        elif any(word in description_lower for word in ['jacket', 'coat']):
+            return "Outerwear/Functional (practical and stylish)"
+
+        return "Versatile style (suitable for multiple aesthetics)"
+
+    def extract_occasion(self, description):
+        """Extract occasion information"""
+        if any(word in description.lower() for word in ['formal', 'business', 'suit']):
+            return "Formal occasions, business settings"
+        elif any(word in description.lower() for word in ['casual', 'everyday']):
+            return "Casual wear, everyday use"
+        else:
+            return "Versatile for multiple occasions"
+
+    def generate_styling_tips(self, description):
+        """Generate styling tips based on the garment"""
+        garment_type = self.extract_garment_type(description).lower()
+        pattern = self.extract_pattern(description).lower()
+
+        tips = []
+
+        if 'dress' in garment_type:
+            tips.extend([
+                "• Pair with a denim jacket for casual daywear",
+                "• Add heels and accessories for evening events",
+                "• Layer with a cardigan for office-appropriate styling"
+            ])
+        elif 'shirt' in garment_type or 'blouse' in garment_type:
+            tips.extend([
+                "• Tuck into high-waisted pants for a polished look",
+                "• Wear open over a tank top for layered styling",
+                "• Knot at the waist for a casual, trendy appearance"
+            ])
+        elif 'pants' in garment_type or 'jeans' in garment_type:
+            tips.extend([
+                "• Pair with a fitted top to balance proportions",
+                "• Add a blazer for business casual styling",
+                "• Combine with sneakers for comfortable everyday wear"
+            ])
+
+        if 'floral' in pattern:
+            tips.append("• Keep accessories minimal to let the pattern shine")
+        elif 'solid' in pattern:
+            tips.append("• Perfect base for statement accessories and bold jewelry")
+
+        return '\n'.join(tips) if tips else "• Versatile piece suitable for various styling approaches"
+
+    def get_versatility_assessment(self, description):
+        """Assess the versatility of the garment"""
+        garment_type = self.extract_garment_type(description).lower()
+        colors = self.extract_colors(description).lower()
+        pattern = self.extract_pattern(description).lower()
+
+        versatility_score = 0
+        assessment_parts = []
+
+        # Assess based on garment type
+        if any(item in garment_type for item in ['dress', 'shirt', 'blouse', 'pants', 'jeans']):
+            versatility_score += 2
+            assessment_parts.append("highly versatile garment type")
+
+        # Assess based on colors
+        if any(color in colors for color in ['black', 'white', 'navy', 'gray']):
+            versatility_score += 2
+            assessment_parts.append("neutral color palette")
+        elif colors == "colors not clearly identified":
+            versatility_score += 1
+            assessment_parts.append("adaptable color scheme")
+
+        # Assess based on pattern
+        if 'solid' in pattern:
+            versatility_score += 2
+            assessment_parts.append("solid pattern for easy mixing")
+        elif any(p in pattern for p in ['floral', 'striped']):
+            versatility_score += 1
+            assessment_parts.append("distinctive pattern adds character")
+
+        if versatility_score >= 4:
+            return f"This is a {', '.join(assessment_parts)} making it an excellent wardrobe staple."
+        elif versatility_score >= 2:
+            return f"Features {', '.join(assessment_parts)} providing good styling flexibility."
+        else:
+            return "Offers unique styling opportunities for specific occasions."
 
 # Initialize analyzer
-analyzer = OllamaFashionAnalyzer()
+analyzer = HuggingFaceFashionAnalyzer()
 
 # Request/Response models
 class AnalysisResponse(BaseModel):
@@ -171,14 +1191,13 @@ async def analyze_image(file: UploadFile = File(...)):
 async def health_check():
     """Health check endpoint"""
     try:
-        # Test Ollama connection
-        response = requests.get(f"{analyzer.base_url}/api/tags", timeout=5)
-        if response.status_code == 200:
-            return {"status": "healthy", "ollama": "connected"}
+        # Test HuggingFace models availability
+        if hasattr(analyzer, 'image_to_text') and analyzer.image_to_text is not None:
+            return {"status": "healthy", "models": "loaded", "device": analyzer.device}
         else:
-            return {"status": "unhealthy", "ollama": "disconnected"}
-    except:
-        return {"status": "unhealthy", "ollama": "disconnected"}
+            return {"status": "unhealthy", "models": "not_loaded"}
+    except Exception as e:
+        return {"status": "unhealthy", "error": str(e)}
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7861)

requirements.txt

@@ -1,6 +1,56 @@
+accelerate==1.8.1
+annotated-types==0.7.0
+anyio==3.7.1
+certifi==2025.6.15
+charset-normalizer==3.4.2
+click==8.2.1
 fastapi==0.104.1
-uvicorn==0.24.0
-requests==2.31.0
+filelock==3.18.0
+fsspec==2025.5.1
+h11==0.16.0
+hf-xet==1.1.5
+huggingface-hub==0.33.0
+idna==3.10
+Jinja2==3.1.6
+MarkupSafe==3.0.2
+mpmath==1.3.0
+networkx==3.5
+numpy==2.3.1
+nvidia-cublas-cu12==12.6.4.1
+nvidia-cuda-cupti-cu12==12.6.80
+nvidia-cuda-nvrtc-cu12==12.6.77
+nvidia-cuda-runtime-cu12==12.6.77
+nvidia-cudnn-cu12==9.5.1.17
+nvidia-cufft-cu12==11.3.0.4
+nvidia-cufile-cu12==1.11.1.6
+nvidia-curand-cu12==10.3.7.77
+nvidia-cusolver-cu12==11.7.1.2
+nvidia-cusparse-cu12==12.5.4.2
+nvidia-cusparselt-cu12==0.6.3
+nvidia-nccl-cu12==2.26.2
+nvidia-nvjitlink-cu12==12.6.85
+nvidia-nvtx-cu12==12.6.77
+packaging==25.0
 Pillow==10.0.1
+psutil==7.0.0
 pydantic==2.4.2
-python-multipart
+pydantic_core==2.10.1
+python-multipart==0.0.20
+PyYAML==6.0.2
+regex==2024.11.6
+requests==2.31.0
+safetensors==0.5.3
+setuptools==80.9.0
+sniffio==1.3.1
+starlette==0.27.0
+sympy==1.14.0
+timm==1.0.15
+tokenizers==0.21.1
+torch==2.7.1
+torchvision==0.22.1
+tqdm==4.67.1
+transformers==4.52.4
+triton==3.3.1
+typing_extensions==4.14.0
+urllib3==2.5.0
+uvicorn==0.24.0

test_hf_conversion.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""
+Test script to verify HuggingFace conversion works
+"""
+
+import sys
+import os
+
+def test_imports():
+    """Test if all required imports work"""
+    try:
+        print("Testing imports...")
+        
+        # Test basic imports
+        from PIL import Image
+        import io
+        print("✅ PIL and io imports successful")
+        
+        # Test transformers import
+        try:
+            from transformers import pipeline
+            print("✅ transformers import successful")
+        except ImportError as e:
+            print(f"❌ transformers import failed: {e}")
+            return False
+            
+        # Test torch import
+        try:
+            import torch
+            print(f"✅ torch import successful (version: {torch.__version__})")
+            print(f"   CUDA available: {torch.cuda.is_available()}")
+        except ImportError as e:
+            print(f"❌ torch import failed: {e}")
+            return False
+            
+        return True
+        
+    except Exception as e:
+        print(f"❌ Import test failed: {e}")
+        return False
+
+def test_pipeline_creation():
+    """Test if we can create the HuggingFace pipeline"""
+    try:
+        print("\nTesting pipeline creation...")
+        
+        from transformers import pipeline
+        
+        # Try to create image captioning pipeline
+        print("Creating image-to-text pipeline...")
+        image_to_text = pipeline(
+            "image-to-text",
+            model="Salesforce/blip-image-captioning-base",
+            device=-1  # Force CPU to avoid GPU issues
+        )
+        print("✅ Image-to-text pipeline created successfully")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Pipeline creation failed: {e}")
+        return False
+
+def test_basic_functionality():
+    """Test basic functionality with a simple image"""
+    try:
+        print("\nTesting basic functionality...")
+        
+        from transformers import pipeline
+        from PIL import Image
+        import io
+        
+        # Create a simple test image
+        test_image = Image.new('RGB', (100, 100), color='red')
+        
+        # Create pipeline
+        image_to_text = pipeline(
+            "image-to-text",
+            model="Salesforce/blip-image-captioning-base",
+            device=-1
+        )
+        
+        # Test image captioning
+        result = image_to_text(test_image)
+        print(f"✅ Image captioning successful: {result}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Basic functionality test failed: {e}")
+        return False
+
+def main():
+    """Run all tests"""
+    print("🧪 Testing HuggingFace Fashion Analyzer Conversion")
+    print("=" * 50)
+    
+    tests = [
+        ("Import Test", test_imports),
+        ("Pipeline Creation Test", test_pipeline_creation),
+        ("Basic Functionality Test", test_basic_functionality)
+    ]
+    
+    passed = 0
+    total = len(tests)
+    
+    for test_name, test_func in tests:
+        print(f"\n🔍 Running {test_name}...")
+        try:
+            if test_func():
+                print(f"✅ {test_name} PASSED")
+                passed += 1
+            else:
+                print(f"❌ {test_name} FAILED")
+        except Exception as e:
+            print(f"❌ {test_name} FAILED with exception: {e}")
+    
+    print("\n" + "=" * 50)
+    print(f"📊 Test Results: {passed}/{total} tests passed")
+    
+    if passed == total:
+        print("🎉 All tests passed! HuggingFace conversion is ready.")
+        return True
+    else:
+        print("⚠️  Some tests failed. Check the errors above.")
+        return False
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)