Upload evaluation/main_model_evaluation.py with huggingface_hub

evaluation/main_model_evaluation.py

@@ -19,7 +19,7 @@ import warnings
 warnings.filterwarnings('ignore')
 from transformers import CLIPProcessor, CLIPModel as CLIPModel_transformers
 
-from config import main_model_path, hierarchy_model_path, color_emb_dim, hierarchy_emb_dim, local_dataset_path, column_local_image_path
+from config import main_model_path, hierarchy_model_path, color_model_path, color_emb_dim, hierarchy_emb_dim, local_dataset_path, column_local_image_path
 
 
 def create_fashion_mnist_to_hierarchy_mapping(hierarchy_classes):
@@ -508,6 +508,15 @@ def load_local_validation_dataset(max_samples=5000):
         print("❌ No valid samples after filtering.")
         return None
     
+    # NO COLOR FILTERING for local dataset - keep all colors for comprehensive evaluation
+    if 'color' in df_clean.columns:
+        print(f"🎨 Total unique colors in dataset: {len(df_clean['color'].unique())}")
+        print(f"🎨 Colors found: {sorted(df_clean['color'].unique())}")
+        print(f"🎨 Color distribution (top 15):")
+        color_counts = df_clean['color'].value_counts()
+        for color in color_counts.index[:15]:  # Show top 15 colors
+            print(f"  {color}: {color_counts[color]} samples")
+    
     # Ensure we have required columns
     required_cols = ['text', 'hierarchy']
     missing_cols = [col for col in required_cols if col not in df_clean.columns]
@@ -515,9 +524,10 @@ def load_local_validation_dataset(max_samples=5000):
         print(f"❌ Missing required columns: {missing_cols}")
         return None
     
-    # Limit to max_samples
+    # Limit to max_samples with RANDOM SAMPLING to get diverse colors
     if len(df_clean) > max_samples:
-        df_clean = df_clean.head(max_samples)
+        df_clean = df_clean.sample(n=max_samples, random_state=42)  
+        print(f"📊 Randomly sampled {max_samples} samples")
     
     print(f"📊 Using {len(df_clean)} samples for evaluation")
     print(f" Samples per hierarchy:")
@@ -525,6 +535,14 @@ def load_local_validation_dataset(max_samples=5000):
         count = len(df_clean[df_clean['hierarchy'] == hierarchy])
         print(f"  {hierarchy}: {count} samples")
     
+    # Show color distribution after sampling
+    if 'color' in df_clean.columns:
+        print(f"\n🎨 Color distribution in sampled data:")
+        color_counts = df_clean['color'].value_counts()
+        print(f"   Total unique colors: {len(color_counts)}")
+        for color in color_counts.index[:15]:  # Show top 15
+            print(f"   {color}: {color_counts[color]} samples")
+    
     return LocalDataset(df_clean)
 
 
@@ -726,7 +744,12 @@ class ColorHierarchyEvaluator:
         return np.vstack(all_embeddings), all_colors, all_hierarchies
 
     def extract_baseline_embeddings_batch(self, dataloader, embedding_type='text', max_samples=10000):
-        """Extract embeddings from baseline Fashion CLIP model"""
+        """
+        Extract embeddings from baseline Fashion CLIP model.
+        
+        This method properly processes images and text through the Fashion-CLIP processor
+        and applies L2 normalization to embeddings, matching the evaluation in evaluate_color_embeddings.py
+        """
         all_embeddings = []
         all_colors = []
         all_hierarchies = []
@@ -739,23 +762,57 @@ class ColorHierarchyEvaluator:
                     break
                     
                 images, texts, colors, hierarchies = batch
-                images = images.to(self.device)
-                images = images.expand(-1, 3, -1, -1)  # Ensure 3 channels
-                
-                # Process text inputs with baseline processor
-                text_inputs = self.baseline_processor(text=texts, padding=True, return_tensors="pt")
-                text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
-                
-                # Forward pass through baseline model
-                outputs = self.baseline_model(**text_inputs, pixel_values=images)
                 
                 # Extract embeddings based on type
                 if embedding_type == 'text':
-                    embeddings = outputs.text_embeds
+                    # Process text through Fashion-CLIP processor
+                    text_inputs = self.baseline_processor(text=texts, return_tensors="pt", padding=True, truncation=True, max_length=77)
+                    text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
+                    
+                    # Get text features using the dedicated method
+                    text_features = self.baseline_model.get_text_features(**text_inputs)
+                    
+                    # Apply L2 normalization (critical for CLIP!)
+                    text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+                    embeddings = text_features
+                    
                 elif embedding_type == 'image':
-                    embeddings = outputs.image_embeds
+                    # Convert tensor images back to PIL Images for proper processing
+                    pil_images = []
+                    for i in range(images.shape[0]):
+                        img_tensor = images[i]
+                        
+                        # Denormalize if the images were normalized (undo ImageNet normalization)
+                        # Check if images are normalized (values outside [0,1])
+                        if img_tensor.min() < 0 or img_tensor.max() > 1:
+                            # Undo ImageNet normalization
+                            mean = torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1)
+                            std = torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1)
+                            img_tensor = img_tensor * std + mean
+                            img_tensor = torch.clamp(img_tensor, 0, 1)
+                        
+                        # Convert to PIL Image
+                        img_pil = transforms.ToPILImage()(img_tensor)
+                        pil_images.append(img_pil)
+                    
+                    # Process images through Fashion-CLIP processor (will apply its own normalization)
+                    image_inputs = self.baseline_processor(images=pil_images, return_tensors="pt")
+                    image_inputs = {k: v.to(self.device) for k, v in image_inputs.items()}
+                    
+                    # Get image features using the dedicated method
+                    image_features = self.baseline_model.get_image_features(**image_inputs)
+                    
+                    # Apply L2 normalization (critical for CLIP!)
+                    image_features = image_features / image_features.norm(dim=-1, keepdim=True)
+                    embeddings = image_features
+                    
                 else:
-                    embeddings = outputs.text_embeds
+                    # Default to text
+                    text_inputs = self.baseline_processor(text=texts, return_tensors="pt", padding=True, truncation=True, max_length=77)
+                    text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
+                    text_features = self.baseline_model.get_text_features(**text_inputs)
+                    text_features = text_features / text_features.norm(dim=-1, keepdim=True)
+                    embeddings = text_features
                 
                 all_embeddings.append(embeddings.cpu().numpy())
                 all_colors.extend(colors)
@@ -764,62 +821,13 @@ class ColorHierarchyEvaluator:
                 sample_count += len(images)
                 
                 # Clear GPU memory
-                del images, text_inputs, outputs, embeddings
-                torch.cuda.empty_cache() if torch.cuda.is_available() else None
-        
-        return np.vstack(all_embeddings), all_colors, all_hierarchies
-
-    def extract_full_embeddings(self, dataloader, embedding_type='text', max_samples=10000):
-        """
-        Extrait TOUTES les dimensions des embeddings du modèle entraîné (pas seulement les sous-espaces spécialisés)
-        
-        Cette méthode permet de comparer les performances en utilisant toutes les dimensions disponibles,
-        similaire à la baseline qui utilise toutes ses dimensions.
-        
-        Différence avec extract_color_embeddings et extract_hierarchy_embeddings:
-        - extract_color_embeddings: utilise seulement dims 0-15 (16 dimensions)
-        - extract_hierarchy_embeddings: utilise seulement dims 16-79 (64 dimensions)
-        - extract_full_embeddings: utilise toutes les dimensions (ex: 512 dimensions)
-        
-        Cela peut améliorer les performances car toutes les informations sont disponibles.
-        """
-        all_embeddings = []
-        all_colors = []
-        all_hierarchies = []
-
-        sample_count = 0
-        with torch.no_grad():
-            for batch in tqdm(dataloader, desc=f"Extracting {embedding_type} FULL embeddings (all dims)"):
-                if sample_count >= max_samples:
-                    break
-
-                images, texts, colors, hierarchies = batch
-                images = images.to(self.device)
-                images = images.expand(-1, 3, -1, -1)
-
-                text_inputs = self.processor(text=texts, padding=True, return_tensors="pt")
-                text_inputs = {k: v.to(self.device) for k, v in text_inputs.items()}
-
-                outputs = self.model(**text_inputs, pixel_values=images)
-
-                if embedding_type == 'text':
-                    embeddings = outputs.text_embeds
-                elif embedding_type == 'image':
-                    embeddings = outputs.image_embeds
+                del embeddings
+                if embedding_type == 'image':
+                    del pil_images, image_inputs
                 else:
-                    embeddings = outputs.text_embeds
-
-                # Utiliser TOUTES les dimensions (pas seulement un sous-espace)
-                # Cela permet d'avoir accès à toute l'information disponible dans l'embedding
-                all_embeddings.append(embeddings.cpu().numpy())
-                all_colors.extend(colors)
-                all_hierarchies.extend(hierarchies)
-
-                sample_count += len(images)
-
-                del images, text_inputs, outputs, embeddings
+                    del text_inputs
                 torch.cuda.empty_cache() if torch.cuda.is_available() else None
-
+        
         return np.vstack(all_embeddings), all_colors, all_hierarchies
 
     def compute_similarity_metrics(self, embeddings, labels):
@@ -1052,75 +1060,55 @@ class ColorHierarchyEvaluator:
 
         results = {}
 
-        # ========== COLOR EVALUATION (DIMS 0-15) ==========
-        print("\n🎨 COLOR EVALUATION (dims 0-15)")
-        print("=" * 50)
-        
-        # Text color embeddings
-        print("\n📝 Extracting text color embeddings...")
-        text_color_embeddings, text_colors, _ = self.extract_color_embeddings(dataloader, 'text', max_samples)
-        print(f"   Text color embeddings shape: {text_color_embeddings.shape}")
-        text_color_metrics = self.compute_similarity_metrics(text_color_embeddings, text_colors)
-        text_color_class = self.evaluate_classification_performance(
-            text_color_embeddings, text_colors, "Text Color Embeddings (16D)", "Color"
-        )
-        text_color_metrics.update(text_color_class)
-        results['text_color'] = text_color_metrics
-
-        del text_color_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-
-        # Image color embeddings
-        print("\n🖼️ Extracting image color embeddings...")
-        image_color_embeddings, image_colors, _ = self.extract_color_embeddings(dataloader, 'image', max_samples)
-        print(f"   Image color embeddings shape: {image_color_embeddings.shape}")
-        image_color_metrics = self.compute_similarity_metrics(image_color_embeddings, image_colors)
-        image_color_class = self.evaluate_classification_performance(
-            image_color_embeddings, image_colors, "Image Color Embeddings (16D)", "Color"
-        )
-        image_color_metrics.update(image_color_class)
-        results['image_color'] = image_color_metrics
-
-        del image_color_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
+        # ========== EXTRACT FULL EMBEDDINGS FOR ENSEMBLE ==========
+        print("\n📦 Extracting full 512-dimensional embeddings for ensemble...")
+        text_full_embeddings, text_colors_full, text_hierarchies_full = self.extract_full_embeddings(dataloader, 'text', max_samples)
+        image_full_embeddings, image_colors_full, image_hierarchies_full = self.extract_full_embeddings(dataloader, 'image', max_samples)
+        print(f"   Text full embeddings shape: {text_full_embeddings.shape}")
+        print(f"   Image full embeddings shape: {image_full_embeddings.shape}")
 
-        # ========== HIERARCHY EVALUATION (DIMS 16-79) ==========
-        print("\n📋 HIERARCHY EVALUATION (dims 16-79)")
+        # ========== HIERARCHY EVALUATION (DIMS 16-79) WITH ENSEMBLE ==========
+        print("\n📋 HIERARCHY EVALUATION (dims 16-79) - Using Ensemble")
         print("=" * 50)
         
-        # Text hierarchy embeddings
-        print("\n📝 Extracting text hierarchy embeddings...")
-        text_hierarchy_embeddings, _, text_hierarchies = self.extract_hierarchy_embeddings(dataloader, 'text', max_samples)
-        print(f"   Text hierarchy embeddings shape: {text_hierarchy_embeddings.shape}")
-        text_hierarchy_metrics = self.compute_similarity_metrics(text_hierarchy_embeddings, text_hierarchies)
+        # Extract specialized hierarchy embeddings (dims 16-79)
+        print("\n📝 Extracting specialized text hierarchy embeddings (dims 16-79)...")
+        text_hierarchy_embeddings_spec = text_full_embeddings[:, self.color_emb_dim:self.color_emb_dim+self.hierarchy_emb_dim]  # dims 16-79
+        print(f"   Specialized text hierarchy embeddings shape: {text_hierarchy_embeddings_spec.shape}")
+        text_hierarchy_metrics = self.compute_similarity_metrics(text_hierarchy_embeddings_spec, text_hierarchies_full)
+        # Use ensemble: combine specialized (64D) + full (512D)
         text_hierarchy_class = self.evaluate_classification_performance(
-            text_hierarchy_embeddings, text_hierarchies, "Text Hierarchy Embeddings (64D)", "Hierarchy"
+            text_hierarchy_embeddings_spec, text_hierarchies_full,
+            "Text Hierarchy Embeddings (Ensemble)", "Hierarchy",
+            full_embeddings=text_full_embeddings, ensemble_weight=0.4
         )
         text_hierarchy_metrics.update(text_hierarchy_class)
         results['text_hierarchy'] = text_hierarchy_metrics
 
-        del text_hierarchy_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-
-        # Image hierarchy embeddings
-        print("\n🖼️ Extracting image hierarchy embeddings...")
-        image_hierarchy_embeddings, _, image_hierarchies = self.extract_hierarchy_embeddings(dataloader, 'image', max_samples)
-        print(f"   Image hierarchy embeddings shape: {image_hierarchy_embeddings.shape}")
-        image_hierarchy_metrics = self.compute_similarity_metrics(image_hierarchy_embeddings, image_hierarchies)
+        # Image hierarchy embeddings with ensemble
+        print("\n🖼️ Extracting specialized image hierarchy embeddings (dims 16-79)...")
+        image_hierarchy_embeddings_spec = image_full_embeddings[:, self.color_emb_dim:self.color_emb_dim+self.hierarchy_emb_dim]  # dims 16-79
+        print(f"   Specialized image hierarchy embeddings shape: {image_hierarchy_embeddings_spec.shape}")
+        image_hierarchy_metrics = self.compute_similarity_metrics(image_hierarchy_embeddings_spec, image_hierarchies_full)
         image_hierarchy_class = self.evaluate_classification_performance(
-            image_hierarchy_embeddings, image_hierarchies, "Image Hierarchy Embeddings (64D)", "Hierarchy"
+            image_hierarchy_embeddings_spec, image_hierarchies_full,
+            "Image Hierarchy Embeddings (Ensemble)", "Hierarchy",
+            full_embeddings=image_full_embeddings, ensemble_weight=0.4
         )
         image_hierarchy_metrics.update(image_hierarchy_class)
         results['image_hierarchy'] = image_hierarchy_metrics
 
-        del image_hierarchy_embeddings
+        # Cleanup
+        del text_full_embeddings, image_full_embeddings
+        del text_color_embeddings_spec, image_color_embeddings_spec
+        del text_hierarchy_embeddings_spec, image_hierarchy_embeddings_spec
         torch.cuda.empty_cache() if torch.cuda.is_available() else None
 
         # ========== SAVE VISUALIZATIONS ==========
         os.makedirs(self.directory, exist_ok=True)
-        for key in ['text_color', 'image_color', 'text_hierarchy', 'image_hierarchy']:
+        for key in ['text_hierarchy', 'image_hierarchy']:
             results[key]['figure'].savefig(
-                f"{self.directory}/{key.replace('_', '_')}_confusion_matrix.png",
+                f"{self.directory}/fashion_{key.replace('_', '_')}_confusion_matrix.png",
                 dpi=300,
                 bbox_inches='tight',
             )
@@ -1245,11 +1233,11 @@ class ColorHierarchyEvaluator:
         return results
 
     def evaluate_local_validation(self, max_samples):
-        """Evaluate both color and hierarchy embeddings on local validation dataset"""
+        """Evaluate both color and hierarchy embeddings on local validation dataset (NO ENSEMBLE - only specialized embeddings)"""
         print(f"\n{'='*60}")
         print("Evaluating Local Validation Dataset")
-        print("  Color embeddings: dims 0-15")
-        print("  Hierarchy embeddings: dims 16-79")
+        print("  Color embeddings: dims 0-15 (specialized only, no ensemble)")
+        print("  Hierarchy embeddings: dims 16-79 (specialized only, no ensemble)")
         print(f"Max samples: {max_samples}")
         print(f"{'='*60}")
 
@@ -1283,8 +1271,8 @@ class ColorHierarchyEvaluator:
 
         results = {}
 
-        # ========== COLOR EVALUATION (DIMS 0-15) ==========
-        print("\n🎨 COLOR EVALUATION (dims 0-15)")
+        # ========== COLOR EVALUATION (DIMS 0-15) - SPECIALIZED ONLY ==========
+        print("\n🎨 COLOR EVALUATION (dims 0-15) - Specialized embeddings only")
         print("=" * 50)
         
         # Text color embeddings
@@ -1315,8 +1303,8 @@ class ColorHierarchyEvaluator:
         del image_color_embeddings
         torch.cuda.empty_cache() if torch.cuda.is_available() else None
 
-        # ========== HIERARCHY EVALUATION (DIMS 16-79) ==========
-        print("\n📋 HIERARCHY EVALUATION (dims 16-79)")
+        # ========== HIERARCHY EVALUATION (DIMS 16-79) - SPECIALIZED ONLY ==========
+        print("\n📋 HIERARCHY EVALUATION (dims 16-79) - Specialized embeddings only")
         print("=" * 50)
         
         # Text hierarchy embeddings
@@ -1359,192 +1347,6 @@ class ColorHierarchyEvaluator:
 
         return results
 
-    def evaluate_full_embeddings(self, dataloader, dataset_name, max_samples=10000):
-        """
-        Evaluate using ALL 512 dimensions from our trained model (not just specialized subspaces)
-        This allows fair comparison with baseline which uses all 512 dimensions.
-        """
-        print(f"\n{'='*60}")
-        print(f"Evaluating {dataset_name} with FULL 512-dimensional embeddings (Our Model)")
-        print(f"Max samples: {max_samples}")
-        print(f"{'='*60}")
-        
-        results = {}
-        
-        # ========== COLOR EVALUATION WITH FULL EMBEDDINGS ==========
-        print("\n🎨 COLOR EVALUATION (512 dims - Full Embeddings)")
-        print("=" * 50)
-        
-        # Text color embeddings
-        print("\n📝 Extracting text FULL embeddings for color classification...")
-        text_full_embeddings, text_colors, _ = self.extract_full_embeddings(dataloader, 'text', max_samples)
-        print(f"   Text full embeddings shape: {text_full_embeddings.shape} (using all {text_full_embeddings.shape[1]} dimensions)")
-        text_color_metrics = self.compute_similarity_metrics(text_full_embeddings, text_colors)
-        text_color_class = self.evaluate_classification_performance(
-            text_full_embeddings, text_colors, "Text Full Embeddings (512D) - Color", "Color"
-        )
-        text_color_metrics.update(text_color_class)
-        results['text_color'] = text_color_metrics
-        
-        del text_full_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-        
-        # Image color embeddings
-        print("\n🖼️ Extracting image FULL embeddings for color classification...")
-        image_full_embeddings, image_colors, _ = self.extract_full_embeddings(dataloader, 'image', max_samples)
-        print(f"   Image full embeddings shape: {image_full_embeddings.shape} (using all {image_full_embeddings.shape[1]} dimensions)")
-        image_color_metrics = self.compute_similarity_metrics(image_full_embeddings, image_colors)
-        image_color_class = self.evaluate_classification_performance(
-            image_full_embeddings, image_colors, "Image Full Embeddings (512D) - Color", "Color"
-        )
-        image_color_metrics.update(image_color_class)
-        results['image_color'] = image_color_metrics
-        
-        del image_full_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-        
-        # ========== HIERARCHY EVALUATION WITH FULL EMBEDDINGS ==========
-        print("\n📋 HIERARCHY EVALUATION (512 dims - Full Embeddings)")
-        print("=" * 50)
-        
-        # Text hierarchy embeddings
-        print("\n📝 Extracting text FULL embeddings for hierarchy classification...")
-        text_full_embeddings, _, text_hierarchies = self.extract_full_embeddings(dataloader, 'text', max_samples)
-        print(f"   Text full embeddings shape: {text_full_embeddings.shape} (using all {text_full_embeddings.shape[1]} dimensions)")
-        text_hierarchy_metrics = self.compute_similarity_metrics(text_full_embeddings, text_hierarchies)
-        text_hierarchy_class = self.evaluate_classification_performance(
-            text_full_embeddings, text_hierarchies, "Text Full Embeddings (512D) - Hierarchy", "Hierarchy"
-        )
-        text_hierarchy_metrics.update(text_hierarchy_class)
-        results['text_hierarchy'] = text_hierarchy_metrics
-        
-        del text_full_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-        
-        # Image hierarchy embeddings
-        print("\n🖼️ Extracting image FULL embeddings for hierarchy classification...")
-        image_full_embeddings, _, image_hierarchies = self.extract_full_embeddings(dataloader, 'image', max_samples)
-        print(f"   Image full embeddings shape: {image_full_embeddings.shape} (using all {image_full_embeddings.shape[1]} dimensions)")
-        image_hierarchy_metrics = self.compute_similarity_metrics(image_full_embeddings, image_hierarchies)
-        image_hierarchy_class = self.evaluate_classification_performance(
-            image_full_embeddings, image_hierarchies, "Image Full Embeddings (512D) - Hierarchy", "Hierarchy"
-        )
-        image_hierarchy_metrics.update(image_hierarchy_class)
-        results['image_hierarchy'] = image_hierarchy_metrics
-        
-        del image_full_embeddings
-        torch.cuda.empty_cache() if torch.cuda.is_available() else None
-        
-        # ========== SAVE VISUALIZATIONS ==========
-        os.makedirs(self.directory, exist_ok=True)
-        dataset_prefix = dataset_name.lower().replace(' ', '_').replace('-', '_')
-        for key in ['text_color', 'image_color', 'text_hierarchy', 'image_hierarchy']:
-            results[key]['figure'].savefig(
-                f"{self.directory}/{dataset_prefix}_full_{key.replace('_', '_')}_confusion_matrix.png",
-                dpi=300,
-                bbox_inches='tight',
-            )
-            plt.close(results[key]['figure'])
-        
-        return results
-
-    def compare_subspace_vs_full_embeddings(self, results_subspace, results_full, dataset_name):
-        """
-        Compare performance between specialized subspaces (16/64 dims) vs full embeddings (512 dims)
-        """
-        print(f"\n{'='*60}")
-        print(f"📊 COMPARISON: Subspace vs Full Embeddings - {dataset_name}")
-        print(f"{'='*60}")
-        
-        comparisons = []
-        
-        # Text Color
-        subspace_color_text_acc = results_subspace.get('text_color', {}).get('accuracy', 0)
-        full_color_text_acc = results_full.get('text_color', {}).get('accuracy', 0)
-        if subspace_color_text_acc > 0 and full_color_text_acc > 0:
-            diff = full_color_text_acc - subspace_color_text_acc
-            comparisons.append({
-                'type': 'Text Color',
-                'subspace': subspace_color_text_acc,
-                'full': full_color_text_acc,
-                'diff': diff,
-                'subspace_dims': '0-15 (16 dims)',
-                'full_dims': 'All 512 dims'
-            })
-        
-        # Image Color
-        subspace_color_img_acc = results_subspace.get('image_color', {}).get('accuracy', 0)
-        full_color_img_acc = results_full.get('image_color', {}).get('accuracy', 0)
-        if subspace_color_img_acc > 0 and full_color_img_acc > 0:
-            diff = full_color_img_acc - subspace_color_img_acc
-            comparisons.append({
-                'type': 'Image Color',
-                'subspace': subspace_color_img_acc,
-                'full': full_color_img_acc,
-                'diff': diff,
-                'subspace_dims': '0-15 (16 dims)',
-                'full_dims': 'All 512 dims'
-            })
-        
-        # Text Hierarchy
-        subspace_hier_text_acc = results_subspace.get('text_hierarchy', {}).get('accuracy', 0)
-        full_hier_text_acc = results_full.get('text_hierarchy', {}).get('accuracy', 0)
-        if subspace_hier_text_acc > 0 and full_hier_text_acc > 0:
-            diff = full_hier_text_acc - subspace_hier_text_acc
-            comparisons.append({
-                'type': 'Text Hierarchy',
-                'subspace': subspace_hier_text_acc,
-                'full': full_hier_text_acc,
-                'diff': diff,
-                'subspace_dims': '16-79 (64 dims)',
-                'full_dims': 'All 512 dims'
-            })
-        
-        # Image Hierarchy
-        subspace_hier_img_acc = results_subspace.get('image_hierarchy', {}).get('accuracy', 0)
-        full_hier_img_acc = results_full.get('image_hierarchy', {}).get('accuracy', 0)
-        if subspace_hier_img_acc > 0 and full_hier_img_acc > 0:
-            diff = full_hier_img_acc - subspace_hier_img_acc
-            comparisons.append({
-                'type': 'Image Hierarchy',
-                'subspace': subspace_hier_img_acc,
-                'full': full_hier_img_acc,
-                'diff': diff,
-                'subspace_dims': '16-79 (64 dims)',
-                'full_dims': 'All 512 dims'
-            })
-        
-        # Display comparisons
-        print("\n📈 PERFORMANCE COMPARISON:")
-        print("-" * 60)
-        for comp in comparisons:
-            better = "✅ Full (512D)" if comp['diff'] > 0 else "✅ Subspace"
-            print(f"\n{comp['type']}:")
-            print(f"  Subspace ({comp['subspace_dims']}): {comp['subspace']*100:.2f}%")
-            print(f"  Full ({comp['full_dims']}): {comp['full']*100:.2f}%")
-            print(f"  Difference: {comp['diff']*100:+.2f}% → {better}")
-        
-        print(f"\n{'='*60}")
-        print("💡 INTERPRETATION:")
-        print(f"{'='*60}")
-        full_better_count = sum(1 for c in comparisons if c['diff'] > 0)
-        
-        if full_better_count > len(comparisons) / 2:
-            print("\n✅ Full embeddings (512D) perform better on most metrics.")
-            print("   This suggests that using all dimensions provides more information")
-            print("   for classification, even though specialized subspaces offer interpretability.")
-        else:
-            print("\n✅ Specialized subspaces perform competitively or better.")
-            print("   This validates the effectiveness of dimensional specialization")
-            print("   while maintaining interpretability advantages.")
-        
-        print("\n📊 Trade-off summary:")
-        print("   • Subspace (16/64 dims): Better interpretability, task-specific")
-        print("   • Full (512 dims): More information, potentially better accuracy")
-        print("   • Use case: Subspace for explainability, Full for maximum performance")
-        
-        return comparisons
-
     def evaluate_baseline_fashion_mnist(self, max_samples=1000):
         """Evaluate baseline Fashion CLIP model on Fashion-MNIST"""
         print(f"\n{'='*60}")
@@ -1568,22 +1370,15 @@ class ColorHierarchyEvaluator:
         
         # Evaluate text embeddings
         print("\n📝 Extracting baseline text embeddings from Fashion-MNIST...")
-        text_embeddings, text_colors, text_hierarchies = self.extract_baseline_embeddings_batch(dataloader, 'text', max_samples)
+        text_embeddings, _, text_hierarchies = self.extract_baseline_embeddings_batch(dataloader, 'text', max_samples)
         print(f"   Baseline text embeddings shape: {text_embeddings.shape} (using all {text_embeddings.shape[1]} dimensions)")
-        text_color_metrics = self.compute_similarity_metrics(text_embeddings, text_colors)
         text_hierarchy_metrics = self.compute_similarity_metrics(text_embeddings, text_hierarchies)
-        
-        text_color_classification = self.evaluate_classification_performance(
-            text_embeddings, text_colors, "Baseline Fashion-MNIST Text Embeddings - Color", "Color"
-        )
         text_hierarchy_classification = self.evaluate_classification_performance(
             text_embeddings, text_hierarchies, "Baseline Fashion-MNIST Text Embeddings - Hierarchy", "Hierarchy"
         )
         
-        text_color_metrics.update(text_color_classification)
         text_hierarchy_metrics.update(text_hierarchy_classification)
         results['text'] = {
-            'color': text_color_metrics,
             'hierarchy': text_hierarchy_metrics
         }
         
@@ -1595,20 +1390,14 @@ class ColorHierarchyEvaluator:
         print("\n🖼️ Extracting baseline image embeddings from Fashion-MNIST...")
         image_embeddings, image_colors, image_hierarchies = self.extract_baseline_embeddings_batch(dataloader, 'image', max_samples)
         print(f"   Baseline image embeddings shape: {image_embeddings.shape} (using all {image_embeddings.shape[1]} dimensions)")
-        image_color_metrics = self.compute_similarity_metrics(image_embeddings, image_colors)
         image_hierarchy_metrics = self.compute_similarity_metrics(image_embeddings, image_hierarchies)
         
-        image_color_classification = self.evaluate_classification_performance(
-            image_embeddings, image_colors, "Baseline Fashion-MNIST Image Embeddings - Color", "Color"
-        )
         image_hierarchy_classification = self.evaluate_classification_performance(
             image_embeddings, image_hierarchies, "Baseline Fashion-MNIST Image Embeddings - Hierarchy", "Hierarchy"
         )
         
-        image_color_metrics.update(image_color_classification)
         image_hierarchy_metrics.update(image_hierarchy_classification)
         results['image'] = {
-            'color': image_color_metrics,
             'hierarchy': image_hierarchy_metrics
         }
         
@@ -1619,7 +1408,7 @@ class ColorHierarchyEvaluator:
         # ========== SAVE VISUALIZATIONS ==========
         os.makedirs(self.directory, exist_ok=True)
         for key in ['text', 'image']:
-            for subkey in ['color', 'hierarchy']:
+            for subkey in ['hierarchy']:
                 figure = results[key][subkey]['figure']
                 figure.savefig(
                     f"{self.directory}/fashion_baseline_{key}_{subkey}_confusion_matrix.png",
@@ -1804,172 +1593,27 @@ class ColorHierarchyEvaluator:
         
         return results
 
-    def analyze_baseline_vs_trained_performance(self, results_trained, results_baseline, dataset_name):
-        """
-        Analyse et explique pourquoi la baseline peut performer mieux que le modèle entraîné
-        
-        Raisons possibles:
-        1. Capacité dimensionnelle: Baseline utilise toutes les dimensions (512), modèle entraîné utilise seulement des sous-espaces (17 ou 64 dims)
-        2. Distribution shift: Dataset de validation différent de celui d'entraînement
-        3. Overfitting: Modèle trop spécialisé sur le dataset d'entraînement
-        4. Généralisation: Baseline pré-entraînée sur un dataset plus large et diversifié
-        5. Perte d'information: Spécialisation excessive peut causer perte d'information générale
-        """
-        print(f"\n{'='*60}")
-        print(f"📊 ANALYSE: Baseline vs Modèle Entraîné - {dataset_name}")
-        print(f"{'='*60}")
-        
-        # Comparer les métriques pour chaque type d'embedding
-        comparisons = []
-        
-        # Text Color
-        trained_color_text_acc = results_trained.get('text_color', {}).get('accuracy', 0)
-        baseline_color_text_acc = results_baseline.get('text', {}).get('color', {}).get('accuracy', 0)
-        if trained_color_text_acc > 0 and baseline_color_text_acc > 0:
-            diff = baseline_color_text_acc - trained_color_text_acc
-            comparisons.append({
-                'type': 'Text Color',
-                'trained': trained_color_text_acc,
-                'baseline': baseline_color_text_acc,
-                'diff': diff,
-                'trained_dims': '0-15 (16 dims)',
-                'baseline_dims': 'All dimensions (512 dims)'
-            })
-        
-        # Image Color
-        trained_color_img_acc = results_trained.get('image_color', {}).get('accuracy', 0)
-        baseline_color_img_acc = results_baseline.get('image', {}).get('color', {}).get('accuracy', 0)
-        if trained_color_img_acc > 0 and baseline_color_img_acc > 0:
-            diff = baseline_color_img_acc - trained_color_img_acc
-            comparisons.append({
-                'type': 'Image Color',
-                'trained': trained_color_img_acc,
-                'baseline': baseline_color_img_acc,
-                'diff': diff,
-                'trained_dims': '0-15 (16 dims)',
-                'baseline_dims': 'All dimensions (512 dims)'
-            })
-        
-        # Text Hierarchy
-        trained_hier_text_acc = results_trained.get('text_hierarchy', {}).get('accuracy', 0)
-        baseline_hier_text_acc = results_baseline.get('text', {}).get('hierarchy', {}).get('accuracy', 0)
-        if trained_hier_text_acc > 0 and baseline_hier_text_acc > 0:
-            diff = baseline_hier_text_acc - trained_hier_text_acc
-            comparisons.append({
-                'type': 'Text Hierarchy',
-                'trained': trained_hier_text_acc,
-                'baseline': baseline_hier_text_acc,
-                'diff': diff,
-                'trained_dims': '16-79 (64 dims)',
-                'baseline_dims': 'All dimensions (512 dims)'
-            })
-        
-        # Image Hierarchy
-        trained_hier_img_acc = results_trained.get('image_hierarchy', {}).get('accuracy', 0)
-        baseline_hier_img_acc = results_baseline.get('image', {}).get('hierarchy', {}).get('accuracy', 0)
-        if trained_hier_img_acc > 0 and baseline_hier_img_acc > 0:
-            diff = baseline_hier_img_acc - trained_hier_img_acc
-            comparisons.append({
-                'type': 'Image Hierarchy',
-                'trained': trained_hier_img_acc,
-                'baseline': baseline_hier_img_acc,
-                'diff': diff,
-                'trained_dims': '16-79 (64 dims)',
-                'baseline_dims': 'All dimensions (512 dims)'
-            })
-        
-        # Afficher les comparaisons
-        print("\n📈 COMPARAISON DES PERFORMANCES:")
-        print("-" * 60)
-        for comp in comparisons:
-            better = "✅ Baseline" if comp['diff'] > 0 else "✅ Modèle Entraîné"
-            print(f"\n{comp['type']}:")
-            print(f"  Modèle Entraîné ({comp['trained_dims']}): {comp['trained']*100:.2f}%")
-            print(f"  Baseline ({comp['baseline_dims']}): {comp['baseline']*100:.2f}%")
-            print(f"  Différence: {comp['diff']*100:+.2f}% → {better}")
-        
-        # Analyse des raisons
-        print(f"\n{'='*60}")
-        print("🔍 EXPLICATIONS POSSIBLES:")
-        print(f"{'='*60}")
-        
-        avg_diff = np.mean([abs(c['diff']) for c in comparisons]) if comparisons else 0
-        baseline_better_count = sum(1 for c in comparisons if c['diff'] > 0)
-        
-        if baseline_better_count > len(comparisons) / 2:
-            print("\n⚠️  La baseline performe mieux sur la majorité des métriques.")
-            print("\nRaisons probables:")
-            print("\n1. 📐 CAPACITÉ DIMENSIONNELLE:")
-            print("   • Baseline: Utilise TOUTES les 512 dimensions des embeddings")
-            print("   • Modèle entraîné: Utilise seulement 16 dims (couleur) ou 64 dims (hiérarchie)")
-            print("   • Impact: La baseline a accès à plus d'information pour la classification")
-            
-            print("\n2. 🎯 SUR-SPÉCIALISATION:")
-            print("   • Le modèle entraîné a été spécialisé pour séparer couleur et hiérarchie")
-            print("   • Cette spécialisation peut causer une perte d'information générale")
-            print("   • Les dimensions non utilisées peuvent contenir de l'information utile")
-            
-            print("\n3. 📊 DISTRIBUTION SHIFT:")
-            print("   • Le dataset de validation peut avoir une distribution différente")
-            print("   • Le modèle entraîné peut avoir overfitté sur le dataset d'entraînement")
-            print("   • La baseline pré-entraînée est plus robuste car entraînée sur plus de données")
-            
-            print("\n4. 🌐 GÉNÉRALISATION:")
-            print("   • Baseline Fashion CLIP: Entraînée sur un large dataset diversifié")
-            print("   • Modèle entraîné: Entraîné sur un dataset plus spécifique")
-            print("   • La baseline peut mieux généraliser à des distributions nouvelles")
-            
-            print("\n5. 🔄 TRADE-OFF SPÉCIALISATION vs CAPACITÉ:")
-            print("   • Spécialisation (modèle entraîné): Meilleure séparation explicable")
-            print("   • Capacité (baseline): Plus d'information pour meilleure performance brute")
-            print("   • C'est un compromis entre interprétabilité et performance")
-            
-        print(f"\n{'='*60}")
-        print("💡 RECOMMANDATIONS:")
-        print(f"{'='*60}")
-        print("\n1. Analyser les matrices de confusion pour voir les types d'erreurs")
-        print("2. Vérifier si le modèle entraîné performe mieux sur le dataset d'entraînement")
-        print("\n3. 🔧 CONSIDÉRER UTILISER TOUTES LES DIMENSIONS POUR LA CLASSIFICATION FINALE:")
-        print("   Actuellement:")
-        print("   • Modèle entraîné: utilise seulement dims 0-15 (couleur) ou dims 16-79 (hiérarchie)")
-        print("   • Baseline: utilise toutes les 512 dimensions")
-        print("   ")
-        print("   Solution proposée:")
-        print("   • Utiliser TOUTES les dimensions du modèle entraîné (ex: 512 dims) pour la classification")
-        print("   • Cela permet d'avoir accès à toute l'information disponible")
-        print("   • Méthode disponible: extract_full_embeddings() pour extraire toutes les dimensions")
-        print("   • Vous pouvez alors comparer:")
-        print("     - Spécialisé (16 ou 64 dims) → meilleur pour interprétabilité")
-        print("     - Complet (512 dims) → meilleur pour performance brute")
-        print("\n4. Utiliser les embeddings spécialisés pour l'interprétabilité, pas pour la classification brute")
-        print("5. Si la performance est critique, combiner spécialisé + général (ensemble)")
-        
-        return comparisons
 
 
 if __name__ == "__main__":
     device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
     print(f"Using device: {device}")
 
-    directory = 'main_model_analysis_model'
+    directory = 'main_model_analysis'
     max_samples = 10000
 
     evaluator = ColorHierarchyEvaluator(device=device, directory=directory)
     
     # Evaluate Fashion-MNIST
     print("\n" + "="*60)
-    print("🚀 Starting evaluation of Fashion-MNIST with Color & Hierarchy embeddings")
+    print("🚀 Starting evaluation of Fashion-MNIST Hierarchy embeddings")
     print("="*60)
     results_fashion = evaluator.evaluate_fashion_mnist(max_samples=max_samples)
 
     print(f"\n{'='*60}")
     print("FASHION-MNIST EVALUATION SUMMARY")
     print(f"{'='*60}")
-    
-    print("\n🎨 COLOR CLASSIFICATION RESULTS (dims 0-15):")
-    print(f"  Text  - NN Acc: {results_fashion['text_color']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion['text_color']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion['text_color']['separation_score']:.4f}")
-    print(f"  Image - NN Acc: {results_fashion['image_color']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion['image_color']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion['image_color']['separation_score']:.4f}")
-    
+
     print("\n📋 HIERARCHY CLASSIFICATION RESULTS (dims 16-79):")
     print(f"  Text  - NN Acc: {results_fashion['text_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion['text_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion['text_hierarchy']['separation_score']:.4f}")
     print(f"  Image - NN Acc: {results_fashion['image_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion['image_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion['image_hierarchy']['separation_score']:.4f}")
@@ -1983,48 +1627,12 @@ if __name__ == "__main__":
     print(f"\n{'='*60}")
     print("BASELINE FASHION-MNIST EVALUATION SUMMARY")
     print(f"{'='*60}")
-    
-    print("\n🎨 COLOR CLASSIFICATION RESULTS (Baseline):")
-    print(f"  Text  - NN Acc: {results_baseline['text']['color']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline['text']['color']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline['text']['color']['separation_score']:.4f}")
-    print(f"  Image - NN Acc: {results_baseline['image']['color']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline['image']['color']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline['image']['color']['separation_score']:.4f}")
-    
+
     print("\n📋 HIERARCHY CLASSIFICATION RESULTS (Baseline):")
     print(f"  Text  - NN Acc: {results_baseline['text']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline['text']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline['text']['hierarchy']['separation_score']:.4f}")
     print(f"  Image - NN Acc: {results_baseline['image']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline['image']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline['image']['hierarchy']['separation_score']:.4f}")
     
-    # Analyse comparative pour Fashion-MNIST
-    evaluator.analyze_baseline_vs_trained_performance(
-        results_fashion, 
-        results_baseline, 
-        "Fashion-MNIST"
-    )
-    
-    # Evaluate Fashion-MNIST with FULL 512-dimensional embeddings
-    print("\n" + "="*60)
-    print("🚀 Starting evaluation of Fashion-MNIST with FULL 512-dimensional embeddings")
-    print("="*60)
-    target_hierarchy_classes = evaluator.validation_hierarchy_classes or evaluator.hierarchy_classes
-    fashion_dataset = load_fashion_mnist_dataset(max_samples, hierarchy_classes=target_hierarchy_classes)
-    fashion_dataloader = DataLoader(fashion_dataset, batch_size=8, shuffle=False, num_workers=0)
-    results_fashion_full = evaluator.evaluate_full_embeddings(fashion_dataloader, "Fashion-MNIST", max_samples=max_samples)
-    
-    print(f"\n{'='*60}")
-    print("FASHION-MNIST FULL EMBEDDINGS (512D) EVALUATION SUMMARY")
-    print(f"{'='*60}")
-    print("\n🎨 COLOR CLASSIFICATION RESULTS (512 dims):")
-    print(f"  Text  - NN Acc: {results_fashion_full['text_color']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion_full['text_color']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion_full['text_color']['separation_score']:.4f}")
-    print(f"  Image - NN Acc: {results_fashion_full['image_color']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion_full['image_color']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion_full['image_color']['separation_score']:.4f}")
-    print("\n📋 HIERARCHY CLASSIFICATION RESULTS (512 dims):")
-    print(f"  Text  - NN Acc: {results_fashion_full['text_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion_full['text_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion_full['text_hierarchy']['separation_score']:.4f}")
-    print(f"  Image - NN Acc: {results_fashion_full['image_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_fashion_full['image_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_fashion_full['image_hierarchy']['separation_score']:.4f}")
-    
-    # Compare subspace vs full embeddings for Fashion-MNIST
-    evaluator.compare_subspace_vs_full_embeddings(
-        results_fashion,
-        results_fashion_full,
-        "Fashion-MNIST"
-    )
-    
+
     # Evaluate KAGL Marqo
     print("\n" + "="*60)
     print("🚀 Starting evaluation of KAGL Marqo with Color & Hierarchy embeddings")
@@ -2062,41 +1670,7 @@ if __name__ == "__main__":
         print("\n📋 HIERARCHY CLASSIFICATION RESULTS (Baseline):")
         print(f"  Text  - NN Acc: {results_baseline_kaggle['text']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline_kaggle['text']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline_kaggle['text']['hierarchy']['separation_score']:.4f}")
         print(f"  Image - NN Acc: {results_baseline_kaggle['image']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline_kaggle['image']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline_kaggle['image']['hierarchy']['separation_score']:.4f}")
-        
-        # Analyse comparative pour KAGL Marqo
-        if results_kaggle is not None:
-            evaluator.analyze_baseline_vs_trained_performance(
-                results_kaggle, 
-                results_baseline_kaggle, 
-                "KAGL Marqo Dataset"
-            )
             
-            # Evaluate KAGL Marqo with FULL 512-dimensional embeddings
-            print("\n" + "="*60)
-            print("🚀 Starting evaluation of KAGL Marqo with FULL 512-dimensional embeddings")
-            print("="*60)
-            kaggle_dataset = load_kaggle_marqo_dataset(evaluator, max_samples)
-            if kaggle_dataset is not None:
-                kaggle_dataloader = DataLoader(kaggle_dataset, batch_size=8, shuffle=False, num_workers=0)
-                results_kaggle_full = evaluator.evaluate_full_embeddings(kaggle_dataloader, "KAGL Marqo", max_samples=max_samples)
-                
-                print(f"\n{'='*60}")
-                print("KAGL MARQO FULL EMBEDDINGS (512D) EVALUATION SUMMARY")
-                print(f"{'='*60}")
-                print("\n🎨 COLOR CLASSIFICATION RESULTS (512 dims):")
-                print(f"  Text  - NN Acc: {results_kaggle_full['text_color']['accuracy']*100:.1f}% | Centroid Acc: {results_kaggle_full['text_color']['centroid_accuracy']*100:.1f}% | Separation: {results_kaggle_full['text_color']['separation_score']:.4f}")
-                print(f"  Image - NN Acc: {results_kaggle_full['image_color']['accuracy']*100:.1f}% | Centroid Acc: {results_kaggle_full['image_color']['centroid_accuracy']*100:.1f}% | Separation: {results_kaggle_full['image_color']['separation_score']:.4f}")
-                print("\n📋 HIERARCHY CLASSIFICATION RESULTS (512 dims):")
-                print(f"  Text  - NN Acc: {results_kaggle_full['text_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_kaggle_full['text_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_kaggle_full['text_hierarchy']['separation_score']:.4f}")
-                print(f"  Image - NN Acc: {results_kaggle_full['image_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_kaggle_full['image_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_kaggle_full['image_hierarchy']['separation_score']:.4f}")
-                
-                # Compare subspace vs full embeddings for KAGL Marqo
-                evaluator.compare_subspace_vs_full_embeddings(
-                    results_kaggle,
-                    results_kaggle_full,
-                    "KAGL Marqo"
-                )
-    
     # Evaluate Local Validation Dataset
     print("\n" + "="*60)
     print("🚀 Starting evaluation of Local Validation Dataset with Color & Hierarchy embeddings")
@@ -2134,46 +1708,3 @@ if __name__ == "__main__":
         print("\n📋 HIERARCHY CLASSIFICATION RESULTS (Baseline):")
         print(f"  Text  - NN Acc: {results_baseline_local['text']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline_local['text']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline_local['text']['hierarchy']['separation_score']:.4f}")
         print(f"  Image - NN Acc: {results_baseline_local['image']['hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_baseline_local['image']['hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_baseline_local['image']['hierarchy']['separation_score']:.4f}")
-        
-        # Analyse comparative pour le dataset de validation local
-        if results_local is not None:
-            evaluator.analyze_baseline_vs_trained_performance(
-                results_local, 
-                results_baseline_local, 
-                "Local Validation Dataset"
-            )
-            
-            # Evaluate Local Validation with FULL 512-dimensional embeddings
-            print("\n" + "="*60)
-            print("🚀 Starting evaluation of Local Validation with FULL 512-dimensional embeddings")
-            print("="*60)
-            local_dataset = load_local_validation_dataset(max_samples)
-            if local_dataset is not None:
-                # Filter to only include hierarchies that exist in our model
-                if len(local_dataset.dataframe) > 0:
-                    valid_df = local_dataset.dataframe[local_dataset.dataframe['hierarchy'].isin(evaluator.hierarchy_classes)]
-                    if len(valid_df) > 0:
-                        if len(valid_df) < len(local_dataset.dataframe):
-                            local_dataset = LocalDataset(valid_df)
-                
-                local_dataloader = DataLoader(local_dataset, batch_size=8, shuffle=False, num_workers=0)
-                results_local_full = evaluator.evaluate_full_embeddings(local_dataloader, "Local Validation", max_samples=max_samples)
-                
-                print(f"\n{'='*60}")
-                print("LOCAL VALIDATION FULL EMBEDDINGS (512D) EVALUATION SUMMARY")
-                print(f"{'='*60}")
-                print("\n🎨 COLOR CLASSIFICATION RESULTS (512 dims):")
-                print(f"  Text  - NN Acc: {results_local_full['text_color']['accuracy']*100:.1f}% | Centroid Acc: {results_local_full['text_color']['centroid_accuracy']*100:.1f}% | Separation: {results_local_full['text_color']['separation_score']:.4f}")
-                print(f"  Image - NN Acc: {results_local_full['image_color']['accuracy']*100:.1f}% | Centroid Acc: {results_local_full['image_color']['centroid_accuracy']*100:.1f}% | Separation: {results_local_full['image_color']['separation_score']:.4f}")
-                print("\n📋 HIERARCHY CLASSIFICATION RESULTS (512 dims):")
-                print(f"  Text  - NN Acc: {results_local_full['text_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_local_full['text_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_local_full['text_hierarchy']['separation_score']:.4f}")
-                print(f"  Image - NN Acc: {results_local_full['image_hierarchy']['accuracy']*100:.1f}% | Centroid Acc: {results_local_full['image_hierarchy']['centroid_accuracy']*100:.1f}% | Separation: {results_local_full['image_hierarchy']['separation_score']:.4f}")
-                
-                # Compare subspace vs full embeddings for Local Validation
-                evaluator.compare_subspace_vs_full_embeddings(
-                    results_local,
-                    results_local_full,
-                    "Local Validation"
-                )
-    
-    print(f"\n✅ Evaluation completed! Check '{directory}/' for visualization files.")