Integrate DeepFashion2 dataset: add evaluation module, utilities, and API endpoints for dataset management and analysis

DEEPFASHION2_INTEGRATION.md

@@ -0,0 +1,243 @@
+# DeepFashion2 Dataset Integration
+
+This document describes the integration of the DeepFashion2 dataset with the Vestiq fashion analysis system.
+
+## Overview
+
+DeepFashion2 is a comprehensive fashion dataset that provides:
+- 491K diverse images of 13 popular clothing categories
+- Bounding box annotations for fashion items
+- Dense pose estimation
+- Commercial-consumer clothes correspondence
+- Scale, occlusion, zoom-in, and viewpoint labels
+
+## Integration Features
+
+### 1. Dataset Loading and Processing
+- **DeepFashion2Dataset**: PyTorch dataset class for loading images and annotations
+- **Category Mapping**: Maps DeepFashion2 categories to yainage90 model categories
+- **Data Transforms**: Standard preprocessing for fashion images
+- **Batch Processing**: Efficient DataLoader implementation
+
+### 2. Evaluation Framework
+- **Detection Accuracy**: Evaluate fashion object detection performance
+- **Feature Quality**: Assess feature extraction capabilities
+- **Classification Metrics**: Precision, recall, F1-score, confusion matrix
+- **Visualization**: Confusion matrix plots and performance charts
+
+### 3. API Endpoints
+- `/deepfashion2/status` - Check integration status and dataset availability
+- `/deepfashion2/statistics` - Get dataset statistics and category distribution
+- `/deepfashion2/evaluate` - Run evaluation using DeepFashion2 as benchmark
+- `/deepfashion2/setup-instructions` - Get setup instructions for the dataset
+
+## Category Mapping
+
+DeepFashion2 uses 13 detailed categories that are mapped to yainage90's 7 categories:
+
+| DeepFashion2 Category | yainage90 Category |
+|----------------------|-------------------|
+| short_sleeved_shirt  | top              |
+| long_sleeved_shirt   | top              |
+| short_sleeved_outwear| outer            |
+| long_sleeved_outwear | outer            |
+| vest                 | top              |
+| sling                | top              |
+| shorts               | bottom           |
+| trousers             | bottom           |
+| skirt                | bottom           |
+| short_sleeved_dress  | dress            |
+| long_sleeved_dress   | dress            |
+| vest_dress           | dress            |
+| sling_dress          | dress            |
+
+## Setup Instructions
+
+### 1. Download the Dataset
+
+The DeepFashion2 dataset requires manual download due to licensing requirements:
+
+1. Visit the official repository: https://github.com/switchablenorms/DeepFashion2
+2. Follow the dataset download instructions
+3. Register and download the dataset files
+
+### 2. Dataset Structure
+
+Extract the dataset to `./data/deepfashion2/` with the following structure:
+
+```
+deepfashion2/
+├── train/
+│   ├── image/          # Training images
+│   └── annos/          # Training annotations (JSON)
+├── validation/
+│   ├── image/          # Validation images
+│   └── annos/          # Validation annotations (JSON)
+└── test/
+    ├── image/          # Test images
+    └── annos/          # Test annotations (JSON)
+```
+
+### 3. Install Dependencies
+
+Install additional dependencies for evaluation:
+
+```bash
+pip install scikit-learn matplotlib seaborn
+```
+
+### 4. Verify Setup
+
+Check the integration status:
+
+```bash
+curl http://localhost:7861/deepfashion2/status
+```
+
+## Usage Examples
+
+### 1. Basic Dataset Loading
+
+```python
+from deepfashion2_utils import DeepFashion2Config, DeepFashion2Dataset
+
+config = DeepFashion2Config()
+dataset = DeepFashion2Dataset(
+    root_dir=config.dataset_root,
+    split='validation',
+    load_annotations=True
+)
+
+# Get a sample
+sample = dataset[0]
+print(f"Image: {sample['image_path']}")
+print(f"Categories: {dataset.get_categories_in_image(sample['annotations'])}")
+```
+
+### 2. Running Evaluation
+
+```python
+from deepfashion2_evaluation import run_full_evaluation
+from fast import analyzer
+
+# Run evaluation with 100 samples
+report_path = run_full_evaluation(analyzer, max_samples=100)
+print(f"Evaluation report saved to: {report_path}")
+```
+
+### 3. API Usage
+
+```bash
+# Check status
+curl -X GET "http://localhost:7861/deepfashion2/status"
+
+# Get dataset statistics
+curl -X GET "http://localhost:7861/deepfashion2/statistics"
+
+# Run evaluation
+curl -X POST "http://localhost:7861/deepfashion2/evaluate?max_samples=50"
+
+# Get setup instructions
+curl -X GET "http://localhost:7861/deepfashion2/setup-instructions"
+```
+
+## Evaluation Metrics
+
+### Detection Accuracy
+- **Category-level accuracy**: How well the model detects clothing categories
+- **Detection score**: IoU-like metric for category overlap
+- **Confusion matrix**: Detailed breakdown of predictions vs ground truth
+
+### Feature Quality
+- **Feature dimension**: Dimensionality of extracted features
+- **Intra-category similarity**: How similar features are within the same category
+- **Inter-category distance**: How well features separate different categories
+- **Feature separability**: Overall quality metric for feature discrimination
+
+## Configuration Options
+
+### DeepFashion2Config
+
+```python
+@dataclass
+class DeepFashion2Config:
+    dataset_root: str = "./data/deepfashion2"
+    categories: List[str] = None  # Auto-populated with 13 categories
+    image_size: Tuple[int, int] = (224, 224)
+    batch_size: int = 32
+    num_workers: int = 4
+```
+
+### Customization
+
+You can customize the configuration for your specific needs:
+
+```python
+config = DeepFashion2Config(
+    dataset_root="/path/to/your/deepfashion2",
+    image_size=(256, 256),
+    batch_size=16
+)
+```
+
+## Performance Considerations
+
+### Memory Usage
+- The dataset is large (~15GB), ensure sufficient disk space
+- Use appropriate batch sizes based on available GPU memory
+- Consider using `num_workers` for faster data loading
+
+### CPU Optimization
+- The system automatically detects CPU vs GPU and optimizes accordingly
+- CPU inference uses float32 precision and limited threads
+- GPU inference uses float16 precision for better performance
+
+### Evaluation Speed
+- Limit `max_samples` for faster evaluation during development
+- Full evaluation on the entire validation set may take significant time
+- Consider running evaluations on a subset for quick feedback
+
+## Troubleshooting
+
+### Common Issues
+
+1. **Dataset not found**: Ensure the dataset is extracted to the correct path
+2. **Permission errors**: Check file permissions for the dataset directory
+3. **Memory errors**: Reduce batch size or number of workers
+4. **Import errors**: Install missing dependencies (scikit-learn, matplotlib, seaborn)
+
+### Debug Mode
+
+Enable debug logging to troubleshoot issues:
+
+```python
+import logging
+logging.basicConfig(level=logging.DEBUG)
+```
+
+## Future Enhancements
+
+### Planned Features
+- **Training Pipeline**: Fine-tune models on DeepFashion2 data
+- **Advanced Metrics**: Add more sophisticated evaluation metrics
+- **Visualization Tools**: Enhanced plotting and analysis tools
+- **Benchmark Comparisons**: Compare against other fashion datasets
+
+### Contributing
+
+To contribute to the DeepFashion2 integration:
+
+1. Fork the repository
+2. Create a feature branch
+3. Add tests for new functionality
+4. Submit a pull request
+
+## References
+
+- [DeepFashion2 Paper](https://arxiv.org/abs/1901.07973)
+- [DeepFashion2 Repository](https://github.com/switchablenorms/DeepFashion2)
+- [yainage90 Models](https://huggingface.co/yainage90)
+
+## License
+
+This integration follows the same license as the main Vestiq project. The DeepFashion2 dataset has its own licensing terms that must be respected.

deepfashion2_evaluation.py

@@ -0,0 +1,405 @@
+"""
+DeepFashion2 Evaluation Module
+Provides evaluation capabilities using DeepFashion2 dataset as benchmark
+for the Vestiq fashion analysis system.
+"""
+
+import torch
+import numpy as np
+from typing import Dict, List, Tuple, Optional
+from sklearn.metrics import accuracy_score, precision_recall_fscore_support, confusion_matrix
+import matplotlib.pyplot as plt
+import seaborn as sns
+from pathlib import Path
+import json
+from tqdm import tqdm
+
+from deepfashion2_utils import (
+    DeepFashion2Config, 
+    DeepFashion2Dataset, 
+    DeepFashion2CategoryMapper,
+    create_deepfashion2_dataloader
+)
+
+class DeepFashion2Evaluator:
+    """Evaluate fashion models using DeepFashion2 dataset"""
+    
+    def __init__(self, config: DeepFashion2Config, analyzer=None):
+        """
+        Initialize evaluator
+        
+        Args:
+            config: DeepFashion2 configuration
+            analyzer: HuggingFaceFashionAnalyzer instance
+        """
+        self.config = config
+        self.analyzer = analyzer
+        self.category_mapper = DeepFashion2CategoryMapper()
+        self.results = {}
+    
+    def evaluate_detection_accuracy(self, split: str = 'validation', 
+                                  max_samples: Optional[int] = None) -> Dict:
+        """
+        Evaluate fashion object detection accuracy on DeepFashion2
+        
+        Args:
+            split: Dataset split to evaluate on
+            max_samples: Maximum number of samples to evaluate (None for all)
+            
+        Returns:
+            Dictionary containing evaluation metrics
+        """
+        if not self.analyzer:
+            raise ValueError("Analyzer not provided")
+        
+        print(f"Evaluating detection accuracy on {split} split...")
+        
+        # Load dataset
+        dataset = DeepFashion2Dataset(
+            root_dir=self.config.dataset_root,
+            split=split,
+            transform=None,
+            load_annotations=True
+        )
+        
+        if max_samples:
+            dataset.image_files = dataset.image_files[:max_samples]
+        
+        # Evaluation metrics
+        true_categories = []
+        predicted_categories = []
+        detection_scores = []
+        
+        for i in tqdm(range(len(dataset)), desc="Evaluating detection"):
+            try:
+                item = dataset[i]
+                image_path = item['image_path']
+                annotations = item['annotations']
+                
+                # Get ground truth categories
+                gt_categories = dataset.get_categories_in_image(annotations)
+                gt_yainage_categories = [
+                    self.category_mapper.map_to_yainage90(cat) 
+                    for cat in gt_categories
+                ]
+                gt_yainage_categories = list(set(gt_yainage_categories))
+                
+                if not gt_yainage_categories:
+                    continue
+                
+                # Get model predictions
+                with open(image_path, 'rb') as f:
+                    image_bytes = f.read()
+                
+                detection_results = self.analyzer.detect_fashion_objects(
+                    self.analyzer.process_image_from_bytes(image_bytes)
+                )
+                
+                if 'detected_items' in detection_results:
+                    pred_categories = [
+                        item['category'] for item in detection_results['detected_items']
+                        if item['confidence'] > 0.5
+                    ]
+                    pred_categories = list(set(pred_categories))
+                    
+                    # Calculate detection score (IoU-like for categories)
+                    if pred_categories and gt_yainage_categories:
+                        intersection = set(pred_categories) & set(gt_yainage_categories)
+                        union = set(pred_categories) | set(gt_yainage_categories)
+                        score = len(intersection) / len(union) if union else 0
+                        detection_scores.append(score)
+                    
+                    # Store for classification metrics
+                    for gt_cat in gt_yainage_categories:
+                        true_categories.append(gt_cat)
+                        predicted_categories.append(
+                            gt_cat if gt_cat in pred_categories else 'none'
+                        )
+                
+            except Exception as e:
+                print(f"Error processing image {i}: {e}")
+                continue
+        
+        # Calculate metrics
+        metrics = self._calculate_classification_metrics(
+            true_categories, predicted_categories
+        )
+        
+        metrics['detection_scores'] = detection_scores
+        metrics['mean_detection_score'] = np.mean(detection_scores) if detection_scores else 0
+        metrics['num_samples'] = len(dataset)
+        
+        self.results['detection_accuracy'] = metrics
+        return metrics
+    
+    def evaluate_feature_extraction(self, split: str = 'validation',
+                                  max_samples: Optional[int] = None) -> Dict:
+        """
+        Evaluate feature extraction quality using DeepFashion2
+        
+        Args:
+            split: Dataset split to evaluate on
+            max_samples: Maximum number of samples to evaluate
+            
+        Returns:
+            Dictionary containing feature evaluation metrics
+        """
+        if not self.analyzer:
+            raise ValueError("Analyzer not provided")
+        
+        print(f"Evaluating feature extraction on {split} split...")
+        
+        dataset = DeepFashion2Dataset(
+            root_dir=self.config.dataset_root,
+            split=split,
+            transform=None,
+            load_annotations=True
+        )
+        
+        if max_samples:
+            dataset.image_files = dataset.image_files[:max_samples]
+        
+        features_by_category = {}
+        feature_dimensions = []
+        
+        for i in tqdm(range(len(dataset)), desc="Extracting features"):
+            try:
+                item = dataset[i]
+                image_path = item['image_path']
+                annotations = item['annotations']
+                
+                # Get ground truth categories
+                gt_categories = dataset.get_categories_in_image(annotations)
+                gt_yainage_categories = [
+                    self.category_mapper.map_to_yainage90(cat) 
+                    for cat in gt_categories
+                ]
+                
+                if not gt_yainage_categories:
+                    continue
+                
+                # Extract features
+                with open(image_path, 'rb') as f:
+                    image_bytes = f.read()
+                
+                feature_results = self.analyzer.extract_fashion_features(
+                    self.analyzer.process_image_from_bytes(image_bytes)
+                )
+                
+                if 'feature_vector' in feature_results:
+                    features = np.array(feature_results['feature_vector'])
+                    feature_dimensions.append(feature_results['feature_dimension'])
+                    
+                    # Group features by category
+                    for category in gt_yainage_categories:
+                        if category not in features_by_category:
+                            features_by_category[category] = []
+                        features_by_category[category].append(features)
+                
+            except Exception as e:
+                print(f"Error processing image {i}: {e}")
+                continue
+        
+        # Calculate feature quality metrics
+        metrics = {
+            'feature_dimension': np.mean(feature_dimensions) if feature_dimensions else 0,
+            'categories_found': list(features_by_category.keys()),
+            'samples_per_category': {
+                cat: len(feats) for cat, feats in features_by_category.items()
+            }
+        }
+        
+        # Calculate intra-category similarity and inter-category distance
+        if len(features_by_category) > 1:
+            intra_similarities = []
+            inter_distances = []
+            
+            categories = list(features_by_category.keys())
+            for i, cat1 in enumerate(categories):
+                cat1_features = np.array(features_by_category[cat1])
+                
+                # Intra-category similarity
+                if len(cat1_features) > 1:
+                    similarities = []
+                    for j in range(len(cat1_features)):
+                        for k in range(j+1, len(cat1_features)):
+                            sim = np.dot(cat1_features[j], cat1_features[k])
+                            similarities.append(sim)
+                    intra_similarities.extend(similarities)
+                
+                # Inter-category distance
+                for j, cat2 in enumerate(categories[i+1:], i+1):
+                    cat2_features = np.array(features_by_category[cat2])
+                    for feat1 in cat1_features:
+                        for feat2 in cat2_features:
+                            dist = np.linalg.norm(feat1 - feat2)
+                            inter_distances.append(dist)
+            
+            metrics['mean_intra_similarity'] = np.mean(intra_similarities) if intra_similarities else 0
+            metrics['mean_inter_distance'] = np.mean(inter_distances) if inter_distances else 0
+            metrics['feature_separability'] = (
+                metrics['mean_inter_distance'] - metrics['mean_intra_similarity']
+            )
+        
+        self.results['feature_extraction'] = metrics
+        return metrics
+    
+    def _calculate_classification_metrics(self, y_true: List[str], 
+                                        y_pred: List[str]) -> Dict:
+        """Calculate classification metrics"""
+        if not y_true or not y_pred:
+            return {}
+        
+        # Get unique labels
+        labels = list(set(y_true + y_pred))
+        
+        # Calculate metrics
+        accuracy = accuracy_score(y_true, y_pred)
+        precision, recall, f1, support = precision_recall_fscore_support(
+            y_true, y_pred, labels=labels, average='weighted', zero_division=0
+        )
+        
+        # Per-class metrics
+        precision_per_class, recall_per_class, f1_per_class, support_per_class = \
+            precision_recall_fscore_support(
+                y_true, y_pred, labels=labels, average=None, zero_division=0
+            )
+        
+        per_class_metrics = {}
+        for i, label in enumerate(labels):
+            per_class_metrics[label] = {
+                'precision': precision_per_class[i],
+                'recall': recall_per_class[i],
+                'f1': f1_per_class[i],
+                'support': support_per_class[i]
+            }
+        
+        return {
+            'accuracy': accuracy,
+            'precision': precision,
+            'recall': recall,
+            'f1': f1,
+            'per_class_metrics': per_class_metrics,
+            'confusion_matrix': confusion_matrix(y_true, y_pred, labels=labels).tolist(),
+            'labels': labels
+        }
+    
+    def generate_evaluation_report(self, output_dir: str = "./evaluation_results") -> str:
+        """Generate comprehensive evaluation report"""
+        output_path = Path(output_dir)
+        output_path.mkdir(exist_ok=True)
+        
+        report_file = output_path / "deepfashion2_evaluation_report.json"
+        
+        # Compile all results
+        full_report = {
+            'config': {
+                'dataset_root': self.config.dataset_root,
+                'categories': self.config.categories,
+                'image_size': self.config.image_size
+            },
+            'results': self.results,
+            'summary': self._generate_summary()
+        }
+        
+        # Save report
+        with open(report_file, 'w') as f:
+            json.dump(full_report, f, indent=2)
+        
+        print(f"Evaluation report saved to: {report_file}")
+        return str(report_file)
+    
+    def _generate_summary(self) -> Dict:
+        """Generate evaluation summary"""
+        summary = {}
+        
+        if 'detection_accuracy' in self.results:
+            det_results = self.results['detection_accuracy']
+            summary['detection'] = {
+                'accuracy': det_results.get('accuracy', 0),
+                'f1_score': det_results.get('f1', 0),
+                'mean_detection_score': det_results.get('mean_detection_score', 0)
+            }
+        
+        if 'feature_extraction' in self.results:
+            feat_results = self.results['feature_extraction']
+            summary['features'] = {
+                'feature_dimension': feat_results.get('feature_dimension', 0),
+                'categories_evaluated': len(feat_results.get('categories_found', [])),
+                'feature_separability': feat_results.get('feature_separability', 0)
+            }
+        
+        return summary
+    
+    def plot_confusion_matrix(self, output_dir: str = "./evaluation_results"):
+        """Plot confusion matrix for detection results"""
+        if 'detection_accuracy' not in self.results:
+            print("No detection results available for plotting")
+            return
+        
+        results = self.results['detection_accuracy']
+        if 'confusion_matrix' not in results:
+            return
+        
+        cm = np.array(results['confusion_matrix'])
+        labels = results['labels']
+        
+        plt.figure(figsize=(10, 8))
+        sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                   xticklabels=labels, yticklabels=labels)
+        plt.title('Fashion Object Detection Confusion Matrix')
+        plt.xlabel('Predicted')
+        plt.ylabel('Actual')
+        
+        output_path = Path(output_dir)
+        output_path.mkdir(exist_ok=True)
+        plt.savefig(output_path / 'confusion_matrix.png', dpi=300, bbox_inches='tight')
+        plt.close()
+        
+        print(f"Confusion matrix saved to: {output_path / 'confusion_matrix.png'}")
+
+def run_full_evaluation(analyzer, config: Optional[DeepFashion2Config] = None,
+                       max_samples: int = 100) -> str:
+    """
+    Run full evaluation pipeline
+    
+    Args:
+        analyzer: HuggingFaceFashionAnalyzer instance
+        config: DeepFashion2 configuration
+        max_samples: Maximum samples to evaluate
+        
+    Returns:
+        Path to evaluation report
+    """
+    if config is None:
+        config = DeepFashion2Config()
+    
+    evaluator = DeepFashion2Evaluator(config, analyzer)
+    
+    print("Starting DeepFashion2 evaluation...")
+    
+    # Run detection evaluation
+    try:
+        evaluator.evaluate_detection_accuracy(max_samples=max_samples)
+        print("✓ Detection evaluation completed")
+    except Exception as e:
+        print(f"✗ Detection evaluation failed: {e}")
+    
+    # Run feature extraction evaluation
+    try:
+        evaluator.evaluate_feature_extraction(max_samples=max_samples)
+        print("✓ Feature extraction evaluation completed")
+    except Exception as e:
+        print(f"✗ Feature extraction evaluation failed: {e}")
+    
+    # Generate report
+    report_path = evaluator.generate_evaluation_report()
+    
+    # Plot confusion matrix
+    try:
+        evaluator.plot_confusion_matrix()
+        print("✓ Confusion matrix plotted")
+    except Exception as e:
+        print(f"✗ Confusion matrix plotting failed: {e}")
+    
+    return report_path

deepfashion2_utils.py

@@ -0,0 +1,280 @@
+"""
+DeepFashion2 Dataset Integration Utilities
+Provides tools for loading, processing, and using the DeepFashion2 dataset
+with the Vestiq fashion analysis system.
+"""
+
+import os
+import json
+import torch
+import numpy as np
+from PIL import Image
+from torch.utils.data import Dataset, DataLoader
+from pathlib import Path
+from typing import Dict, List, Tuple, Optional, Union
+import torchvision.transforms as transforms
+from dataclasses import dataclass, field
+import requests
+import zipfile
+import shutil
+
+@dataclass
+class DeepFashion2Config:
+    """Configuration for DeepFashion2 dataset"""
+    dataset_root: str = "./data/deepfashion2"
+    download_url: str = "https://github.com/switchablenorms/DeepFashion2/releases/download/v1.0/deepfashion2.zip"
+    categories: List[str] = field(default_factory=list)
+    image_size: Tuple[int, int] = (224, 224)
+    batch_size: int = 32
+    num_workers: int = 4
+
+    def __post_init__(self):
+        if not self.categories:
+            # DeepFashion2 13 categories
+            self.categories = [
+                'short_sleeved_shirt', 'long_sleeved_shirt', 'short_sleeved_outwear',
+                'long_sleeved_outwear', 'vest', 'sling', 'shorts', 'trousers',
+                'skirt', 'short_sleeved_dress', 'long_sleeved_dress', 'vest_dress', 'sling_dress'
+            ]
+
+class DeepFashion2CategoryMapper:
+    """Maps DeepFashion2 categories to yainage90 model categories"""
+    
+    def __init__(self):
+        # Mapping from DeepFashion2 categories to yainage90 categories
+        self.df2_to_yainage90 = {
+            'short_sleeved_shirt': 'top',
+            'long_sleeved_shirt': 'top', 
+            'short_sleeved_outwear': 'outer',
+            'long_sleeved_outwear': 'outer',
+            'vest': 'top',
+            'sling': 'top',
+            'shorts': 'bottom',
+            'trousers': 'bottom',
+            'skirt': 'bottom',
+            'short_sleeved_dress': 'dress',
+            'long_sleeved_dress': 'dress',
+            'vest_dress': 'dress',
+            'sling_dress': 'dress'
+        }
+        
+        # Reverse mapping
+        self.yainage90_to_df2 = {}
+        for df2_cat, yainage_cat in self.df2_to_yainage90.items():
+            if yainage_cat not in self.yainage90_to_df2:
+                self.yainage90_to_df2[yainage_cat] = []
+            self.yainage90_to_df2[yainage_cat].append(df2_cat)
+    
+    def map_to_yainage90(self, df2_category: str) -> str:
+        """Map DeepFashion2 category to yainage90 category"""
+        return self.df2_to_yainage90.get(df2_category, 'unknown')
+    
+    def map_from_yainage90(self, yainage_category: str) -> List[str]:
+        """Map yainage90 category to DeepFashion2 categories"""
+        return self.yainage90_to_df2.get(yainage_category, [])
+
+class DeepFashion2Dataset(Dataset):
+    """PyTorch Dataset for DeepFashion2"""
+    
+    def __init__(self, 
+                 root_dir: str,
+                 split: str = 'train',
+                 transform: Optional[transforms.Compose] = None,
+                 load_annotations: bool = True):
+        """
+        Initialize DeepFashion2 dataset
+        
+        Args:
+            root_dir: Root directory of DeepFashion2 dataset
+            split: Dataset split ('train', 'validation', 'test')
+            transform: Image transformations
+            load_annotations: Whether to load bounding box annotations
+        """
+        self.root_dir = Path(root_dir)
+        self.split = split
+        self.transform = transform
+        self.load_annotations = load_annotations
+        self.category_mapper = DeepFashion2CategoryMapper()
+        
+        # Load dataset metadata
+        self.images_dir = self.root_dir / split / "image"
+        self.annos_dir = self.root_dir / split / "annos"
+        
+        # Get all image files
+        self.image_files = []
+        if self.images_dir.exists():
+            self.image_files = list(self.images_dir.glob("*.jpg"))
+        
+        print(f"Found {len(self.image_files)} images in {split} split")
+    
+    def __len__(self):
+        return len(self.image_files)
+    
+    def __getitem__(self, idx):
+        """Get dataset item"""
+        image_path = self.image_files[idx]
+        image_name = image_path.stem
+        
+        # Load image
+        image = Image.open(image_path).convert('RGB')
+        
+        # Load annotations if requested
+        annotations = None
+        if self.load_annotations:
+            anno_path = self.annos_dir / f"{image_name}.json"
+            if anno_path.exists():
+                with open(anno_path, 'r') as f:
+                    annotations = json.load(f)
+        
+        # Apply transforms
+        if self.transform:
+            image = self.transform(image)
+        
+        return {
+            'image': image,
+            'image_path': str(image_path),
+            'image_name': image_name,
+            'annotations': annotations
+        }
+    
+    def get_categories_in_image(self, annotations: Dict) -> List[str]:
+        """Extract categories from annotations"""
+        if not annotations or 'item' not in annotations:
+            return []
+        
+        categories = []
+        for item_id, item_data in annotations['item'].items():
+            if 'category_name' in item_data:
+                categories.append(item_data['category_name'])
+        
+        return list(set(categories))
+
+class DeepFashion2Downloader:
+    """Download and setup DeepFashion2 dataset"""
+    
+    def __init__(self, config: DeepFashion2Config):
+        self.config = config
+        self.dataset_root = Path(config.dataset_root)
+    
+    def download_dataset(self, force_download: bool = False) -> bool:
+        """
+        Download DeepFashion2 dataset
+        
+        Args:
+            force_download: Force re-download even if dataset exists
+            
+        Returns:
+            True if successful, False otherwise
+        """
+        if self.dataset_root.exists() and not force_download:
+            print(f"Dataset already exists at {self.dataset_root}")
+            return True
+        
+        print("DeepFashion2 dataset download requires manual setup.")
+        print("Please follow these steps:")
+        print("1. Visit: https://github.com/switchablenorms/DeepFashion2")
+        print("2. Follow the dataset download instructions")
+        print("3. Extract the dataset to:", self.dataset_root)
+        print("4. Ensure the directory structure is:")
+        print("   deepfashion2/")
+        print("   ├── train/")
+        print("   │   ├── image/")
+        print("   │   └── annos/")
+        print("   ├── validation/")
+        print("   │   ├── image/")
+        print("   │   └── annos/")
+        print("   └── test/")
+        print("       ├── image/")
+        print("       └── annos/")
+        
+        return False
+    
+    def verify_dataset(self) -> bool:
+        """Verify dataset structure"""
+        required_dirs = [
+            self.dataset_root / "train" / "image",
+            self.dataset_root / "train" / "annos",
+            self.dataset_root / "validation" / "image", 
+            self.dataset_root / "validation" / "annos"
+        ]
+        
+        for dir_path in required_dirs:
+            if not dir_path.exists():
+                print(f"Missing required directory: {dir_path}")
+                return False
+        
+        print("Dataset structure verified successfully")
+        return True
+
+def create_deepfashion2_transforms(image_size: Tuple[int, int] = (224, 224)) -> transforms.Compose:
+    """Create standard transforms for DeepFashion2 images"""
+    return transforms.Compose([
+        transforms.Resize(image_size),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+
+def create_deepfashion2_dataloader(config: DeepFashion2Config, 
+                                  split: str = 'train',
+                                  shuffle: bool = True) -> DataLoader:
+    """Create DataLoader for DeepFashion2 dataset"""
+    transform = create_deepfashion2_transforms(config.image_size)
+    
+    dataset = DeepFashion2Dataset(
+        root_dir=config.dataset_root,
+        split=split,
+        transform=transform,
+        load_annotations=True
+    )
+    
+    return DataLoader(
+        dataset,
+        batch_size=config.batch_size,
+        shuffle=shuffle,
+        num_workers=config.num_workers,
+        pin_memory=torch.cuda.is_available()
+    )
+
+def get_deepfashion2_statistics(config: DeepFashion2Config) -> Dict:
+    """Get statistics about the DeepFashion2 dataset"""
+    stats = {
+        'splits': {},
+        'total_images': 0,
+        'categories': config.categories,
+        'category_counts': {cat: 0 for cat in config.categories}
+    }
+    
+    for split in ['train', 'validation', 'test']:
+        try:
+            dataset = DeepFashion2Dataset(
+                root_dir=config.dataset_root,
+                split=split,
+                transform=None,
+                load_annotations=True
+            )
+            
+            split_stats = {
+                'num_images': len(dataset),
+                'categories_found': set()
+            }
+            
+            # Sample a few images to get category statistics
+            sample_size = min(100, len(dataset))
+            for i in range(0, len(dataset), max(1, len(dataset) // sample_size)):
+                item = dataset[i]
+                if item['annotations']:
+                    categories = dataset.get_categories_in_image(item['annotations'])
+                    split_stats['categories_found'].update(categories)
+                    for cat in categories:
+                        if cat in stats['category_counts']:
+                            stats['category_counts'][cat] += 1
+            
+            split_stats['categories_found'] = list(split_stats['categories_found'])
+            stats['splits'][split] = split_stats
+            stats['total_images'] += split_stats['num_images']
+            
+        except Exception as e:
+            print(f"Error processing {split} split: {e}")
+            stats['splits'][split] = {'error': str(e)}
+    
+    return stats

fast.py

@@ -16,6 +16,9 @@ import torchvision.transforms as v2
 from huggingface_hub import PyTorchModelHubMixin
 import numpy as np
 import warnings
+import os
+import json
+from pathlib import Path
 
 # Suppress specific warnings for cleaner output
 warnings.filterwarnings("ignore", message=".*use_fast.*")
@@ -1586,9 +1589,28 @@ class HuggingFaceFashionAnalyzer:
         else:
             return "Offers unique styling opportunities for specific occasions."
 
+# Import DeepFashion2 utilities
+try:
+    from deepfashion2_utils import DeepFashion2Config, get_deepfashion2_statistics
+    from deepfashion2_evaluation import run_full_evaluation
+    DEEPFASHION2_AVAILABLE = True
+except ImportError as e:
+    print(f"DeepFashion2 utilities not available: {e}")
+    DEEPFASHION2_AVAILABLE = False
+
 # Initialize analyzer
 analyzer = HuggingFaceFashionAnalyzer()
 
+# Initialize DeepFashion2 configuration if available
+deepfashion2_config = None
+if DEEPFASHION2_AVAILABLE:
+    try:
+        deepfashion2_config = DeepFashion2Config()
+        print(f"DeepFashion2 integration initialized. Dataset root: {deepfashion2_config.dataset_root}")
+    except Exception as e:
+        print(f"Failed to initialize DeepFashion2 config: {e}")
+        DEEPFASHION2_AVAILABLE = False
+
 # Request/Response models
 class AnalysisResponse(BaseModel):
     analysis: str
@@ -1617,6 +1639,7 @@ async def root():
             <br>
             <button onclick="analyzeImage()" style="padding: 10px 20px; margin: 10px;">Analyze Fashion (Detailed)</button>
             <button onclick="analyzeStructured()" style="padding: 10px 20px; margin: 10px;">Analyze Fashion (Structured)</button>
+            <button onclick="checkDeepFashion2Status()" style="padding: 10px 20px; margin: 10px; background-color: #6f42c1; color: white;">DeepFashion2 Status</button>
             <br>
             <a href="/refined-prompt" target="_blank" style="color: #007bff; text-decoration: none;">View Refined Prompt Format</a>
         </div>
@@ -1682,6 +1705,77 @@ async def root():
                 document.getElementById('analysisText').textContent = 'Error: ' + error.message;
             }
         }
+
+        async function checkDeepFashion2Status() {
+            document.getElementById('analysisText').textContent = 'Checking DeepFashion2 status...';
+            document.getElementById('result').style.display = 'block';
+
+            try {
+                const response = await fetch('/deepfashion2/status');
+                const result = await response.json();
+
+                let statusText = 'DeepFashion2 Integration Status:\\n\\n';
+                statusText += `Available: ${result.available}\\n`;
+
+                if (result.available) {
+                    statusText += `Dataset Exists: ${result.dataset_exists}\\n`;
+                    statusText += `Dataset Root: ${result.dataset_root}\\n`;
+                    statusText += `Categories: ${result.categories.length} categories\\n`;
+                    statusText += `Image Size: ${result.image_size[0]}x${result.image_size[1]}\\n\\n`;
+
+                    if (!result.dataset_exists) {
+                        statusText += 'Dataset not found. Click "Setup Instructions" for download guide.\\n';
+                    } else {
+                        statusText += 'Dataset ready! You can run evaluations.\\n';
+                    }
+                } else {
+                    statusText += `Message: ${result.message}\\n`;
+                }
+
+                document.getElementById('analysisText').textContent = statusText;
+
+                // Add setup instructions button if needed
+                if (result.available && !result.dataset_exists) {
+                    const setupBtn = document.createElement('button');
+                    setupBtn.textContent = 'Get Setup Instructions';
+                    setupBtn.onclick = getSetupInstructions;
+                    setupBtn.style.cssText = 'padding: 10px 20px; margin: 10px; background-color: #17a2b8; color: white;';
+                    document.getElementById('result').appendChild(setupBtn);
+                }
+
+            } catch (error) {
+                document.getElementById('analysisText').textContent = 'Error checking status: ' + error.message;
+            }
+        }
+
+        async function getSetupInstructions() {
+            try {
+                const response = await fetch('/deepfashion2/setup-instructions');
+                const result = await response.json();
+
+                let instructionsText = result.title + '\\n\\n';
+
+                result.steps.forEach(step => {
+                    instructionsText += `Step ${step.step}: ${step.description}\\n`;
+                    if (step.url) instructionsText += `URL: ${step.url}\\n`;
+                    if (step.command) instructionsText += `Command: ${step.command}\\n`;
+                    if (step.structure) {
+                        instructionsText += 'Structure:\\n';
+                        step.structure.forEach(line => instructionsText += `  ${line}\\n`);
+                    }
+                    if (step.endpoint) instructionsText += `Endpoint: ${step.endpoint}\\n`;
+                    instructionsText += '\\n';
+                });
+
+                instructionsText += 'Notes:\\n';
+                result.notes.forEach(note => instructionsText += `• ${note}\\n`);
+
+                document.getElementById('analysisText').textContent = instructionsText;
+
+            } catch (error) {
+                document.getElementById('analysisText').textContent = 'Error getting instructions: ' + error.message;
+            }
+        }
         </script>
     </body>
     </html>
@@ -1800,5 +1894,107 @@ async def health_check():
     except Exception as e:
         return {"status": "unhealthy", "error": str(e)}
 
+# DeepFashion2 API endpoints
+@app.get("/deepfashion2/status")
+async def deepfashion2_status():
+    """Get DeepFashion2 integration status"""
+    if not DEEPFASHION2_AVAILABLE:
+        return {"available": False, "message": "DeepFashion2 utilities not available"}
+
+    if not deepfashion2_config:
+        return {"available": False, "message": "DeepFashion2 configuration not initialized"}
+
+    # Check if dataset exists
+    dataset_path = Path(deepfashion2_config.dataset_root)
+    dataset_exists = dataset_path.exists()
+
+    return {
+        "available": True,
+        "dataset_exists": dataset_exists,
+        "dataset_root": deepfashion2_config.dataset_root,
+        "categories": deepfashion2_config.categories,
+        "image_size": deepfashion2_config.image_size
+    }
+
+@app.get("/deepfashion2/statistics")
+async def deepfashion2_statistics():
+    """Get DeepFashion2 dataset statistics"""
+    if not DEEPFASHION2_AVAILABLE or not deepfashion2_config:
+        raise HTTPException(status_code=503, detail="DeepFashion2 not available")
+
+    try:
+        stats = get_deepfashion2_statistics(deepfashion2_config)
+        return stats
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting statistics: {str(e)}")
+
+@app.post("/deepfashion2/evaluate")
+async def deepfashion2_evaluate(max_samples: int = 50):
+    """Run evaluation using DeepFashion2 dataset"""
+    if not DEEPFASHION2_AVAILABLE or not deepfashion2_config:
+        raise HTTPException(status_code=503, detail="DeepFashion2 not available")
+
+    try:
+        # Run evaluation in background (for demo purposes, limit samples)
+        report_path = run_full_evaluation(analyzer, deepfashion2_config, max_samples=max_samples)
+
+        return {
+            "status": "completed",
+            "report_path": report_path,
+            "max_samples": max_samples,
+            "message": f"Evaluation completed with {max_samples} samples"
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Evaluation failed: {str(e)}")
+
+@app.get("/deepfashion2/setup-instructions")
+async def deepfashion2_setup_instructions():
+    """Get setup instructions for DeepFashion2 dataset"""
+    return {
+        "title": "DeepFashion2 Dataset Setup Instructions",
+        "steps": [
+            {
+                "step": 1,
+                "description": "Visit the official DeepFashion2 repository",
+                "url": "https://github.com/switchablenorms/DeepFashion2"
+            },
+            {
+                "step": 2,
+                "description": "Follow the dataset download instructions in the repository"
+            },
+            {
+                "step": 3,
+                "description": "Create the dataset directory",
+                "command": f"mkdir -p {deepfashion2_config.dataset_root if deepfashion2_config else './data/deepfashion2'}"
+            },
+            {
+                "step": 4,
+                "description": "Extract the dataset with the following structure:",
+                "structure": [
+                    "deepfashion2/",
+                    "├── train/",
+                    "│   ├── image/",
+                    "│   └── annos/",
+                    "├── validation/",
+                    "│   ├── image/",
+                    "│   └── annos/",
+                    "└── test/",
+                    "    ├── image/",
+                    "    └── annos/"
+                ]
+            },
+            {
+                "step": 5,
+                "description": "Verify the setup by checking the status endpoint",
+                "endpoint": "/deepfashion2/status"
+            }
+        ],
+        "notes": [
+            "The DeepFashion2 dataset is large (~15GB) and requires registration",
+            "Make sure you have sufficient disk space",
+            "The dataset contains 491K images across 13 clothing categories"
+        ]
+    }
+
 if __name__ == "__main__":
     uvicorn.run(app, host="0.0.0.0", port=7861)

requirements.txt

@@ -54,3 +54,6 @@ triton==3.3.1
 typing_extensions==4.14.0
 urllib3==2.5.0
 uvicorn==0.24.0
+scikit-learn==1.5.2
+matplotlib==3.9.3
+seaborn==0.13.2