fix: address code review issues from Copilot

- Remove sys.path manipulation from predictor.py (use package imports directly)
- Remove unused OrderedDict import in create_label_mappings.py
- Update preprocessing defaults to 224x224 and imagenet normalization
- Update preprocess_image_batch and resize_image defaults to match
- Fix normalize_rgb docstring to accurately describe both normalization modes
- Update model_registry input_size to 224x224 and add norm_method field
- Make TreeClassifier norm_method configurable (default: imagenet)
- Fix predictor to use self.norm_method instead of hardcoded '0_1'
- Update from_checkpoint to use (224, 224) and imagenet defaults
- Add rgb_norm_method param to RGBClassifier; normalize() now reflects it
- Validate numeric_to_label_dict in upload_to_huggingface.py
- Fix docs: species_filter is inclusion filter, not exclusion
- Fix docs: add --csv_path to inspect_labels.py example commands
- Fix warning message: clarify species_filter is an inclusion filter

Author: Ritesh313

docs/taxonomic_levels.md

@@ -63,7 +63,7 @@ datamodule = NeonCrownDataModule(
 ### Step 1: Run Label Inspection
 
 ```bash
-python processing/misc/inspect_labels.py
+python processing/misc/inspect_labels.py --csv_path path/to/your/labels.csv
 ```
 
 This will show:
@@ -103,20 +103,22 @@ Pinus         6,600 samples    19 species    (Pines)
 If you want taxonomically pure genus-level training:
 
 ```python
-# Option A: Filter specific species codes
+# Option A: Include only specific species codes (all others are excluded)
 datamodule = NeonCrownDataModule(
     ...,
     taxonomic_level="genus",
-    species_filter=["PINACE"],  # Exclude Pinaceae (will filter BEFORE genus extraction)
+    species_filter=["PSMEM", "TSHE"],  # Include only these USDA codes
 )
 
-# Option B: Filter after inspecting
-# See inspect_labels.py output for USDA codes to exclude
-species_to_exclude = ["PINACE", "2PLANT", "2PLANT-S"]  # Example
+# Option B: Build an inclusion list after inspecting
+# See inspect_labels.py output for USDA codes present in your data
+# species_filter keeps only rows WHERE species IS IN the list
+all_codes = [...]  # full list from inspect_labels.py
+species_to_include = [c for c in all_codes if c not in ["PINACE", "2PLANT", "2PLANT-S"]]
 datamodule = NeonCrownDataModule(
     ...,
     taxonomic_level="genus",
-    species_filter=species_to_exclude,
+    species_filter=species_to_include,
 )
 ```
 
@@ -175,13 +177,16 @@ trainer.fit(model, datamodule)
 ### With Filtering
 
 ```python
-# Clean genus-level training (exclude edge cases)
+# Clean genus-level training (include only true genera, omit edge cases)
+# species_filter keeps only rows where species code is in the list
+all_codes = [...]  # get from inspect_labels.py output
+clean_codes = [c for c in all_codes if c not in ["PINACE"]]  # drop Pinaceae
 datamodule = NeonCrownDataModule(
     csv_path="data/metadata/combined_dataset.csv",
     hdf5_path="data/combined_dataset.h5",
     modalities=["rgb"],
     taxonomic_level="genus",
-    species_filter=["PINACE"],  # Exclude Pinaceae family
+    species_filter=clean_codes,  # include all except Pinaceae
     batch_size=64,
 )
 # Now training on 59 true genera only
@@ -262,7 +267,7 @@ These represent unidentified species within that family.
 See docs/taxonomic_levels.md for more information.
 ```
 
-**These are informational** - training will proceed normally. Filter if desired using `species_filter`.
+**These are informational** - training will proceed normally. To exclude them, build an inclusion list with all other codes and pass it to `species_filter` (which keeps only species in the list).
 
 ## FAQ
 
@@ -277,7 +282,7 @@ See docs/taxonomic_levels.md for more information.
 **Q: What about Pinaceae?**
 - It's a family name, not genus, but only 26 samples (0.05%)
 - Keep it (recommended): Represents "unidentified conifer" class
-- Filter it: Use `species_filter=["PINACE"]` if you need taxonomic purity
+- Exclude it: Build an inclusion list of all codes except `"PINACE"` and pass to `species_filter`
 
 **Q: How do I know how many classes I have?**
 ```python
@@ -304,7 +309,7 @@ Expected accuracy ranges on NEON combined dataset (RGB only, ResNet50):
 
 ## Additional Resources
 
-- **Data inspection**: `python processing/misc/inspect_labels.py`
+- **Data inspection**: `python processing/misc/inspect_labels.py --csv_path path/to/labels.csv`
 - **Training examples**: `examples/train.py`
 - **Model architectures**: `docs/training.md`
 - **Data processing**: `docs/processing.md`

neon_tree_classification/core/datamodule.py

@@ -756,8 +756,8 @@ def _create_genus_label_mapping(self) -> Dict[str, int]:
             warnings.warn(
                 f"Found non-alphabetic genus names: {non_alpha_genera}. "
                 f"These may be unidentified species or family names. "
-                f"Run 'python processing/misc/inspect_labels.py' to review. "
-                f"To exclude, use: species_filter=[...]"
+                f"Run 'python processing/misc/inspect_labels.py --csv_path <path>' to review. "
+                f"To include only specific species, use: species_filter=[...]"
             )
 
         # Check for known family names

neon_tree_classification/inference/model_registry.py

@@ -16,7 +16,8 @@
         "num_classes": 167,
         "architecture": "resnet",
         "modality": "rgb",
-        "input_size": (128, 128),
+        "input_size": (224, 224),
+        "norm_method": "imagenet",
         "accuracy": 75.88,  # Test accuracy percentage
         "parameters": "11.2M",
         "url": None,  # To be added when uploaded to HuggingFace
@@ -28,7 +29,8 @@
         "num_classes": 60,
         "architecture": "resnet",
         "modality": "rgb",
-        "input_size": (128, 128),
+        "input_size": (224, 224),
+        "norm_method": "imagenet",
         "accuracy": 72.24,  # Test accuracy percentage
         "parameters": "11.2M",
         "url": None,  # To be added when uploaded to HuggingFace

neon_tree_classification/inference/predictor.py

@@ -8,12 +8,6 @@
 import warnings
 from pathlib import Path
 from typing import Union, List, Dict, Optional, Tuple
-import sys
-
-# Add project root to path for imports
-project_root = Path(__file__).parent.parent.parent
-if str(project_root) not in sys.path:
-    sys.path.insert(0, str(project_root))
 
 from neon_tree_classification.models.rgb_models import create_rgb_model
 from .preprocessing import preprocess_image, preprocess_image_batch
@@ -61,7 +55,8 @@ def __init__(
         label_mapping: Dict,
         taxonomic_level: str,
         device: str = None,
-        input_size: Tuple[int, int] = (128, 128),
+        input_size: Tuple[int, int] = (224, 224),
+        norm_method: str = "imagenet",
     ):
         """
         Initialize tree classifier.
@@ -72,11 +67,13 @@ def __init__(
             taxonomic_level: 'species' or 'genus'
             device: Device for inference ('cpu', 'cuda', 'mps'). Auto-detected if None.
             input_size: Input image size (width, height)
+            norm_method: Normalization method ('imagenet' or '0_1')
         """
         self.model = model
         self.label_mapping = label_mapping
         self.taxonomic_level = taxonomic_level
         self.input_size = input_size
+        self.norm_method = norm_method
 
         # Auto-detect device if not specified
         if device is None:
@@ -176,7 +173,8 @@ def from_checkpoint(
             label_mapping=label_mapping,
             taxonomic_level=taxonomic_level,
             device=device,
-            input_size=(128, 128),
+            input_size=(224, 224),
+            norm_method="imagenet",
         )
 
     @classmethod
@@ -240,7 +238,7 @@ def predict(
             image_input,
             target_size=self.input_size,
             normalize=True,
-            norm_method="0_1",
+            norm_method=self.norm_method,
             return_tensor=True,
             add_batch_dim=True,
             device=self.device,
@@ -299,7 +297,7 @@ def predict_batch(
                 batch,
                 target_size=self.input_size,
                 normalize=True,
-                norm_method="0_1",
+                norm_method=self.norm_method,
                 device=self.device,
             )
 

neon_tree_classification/inference/preprocessing.py

@@ -82,7 +82,7 @@ def load_image(
     )
 
 
-def resize_image(image: Image.Image, target_size: tuple = (128, 128)) -> Image.Image:
+def resize_image(image: Image.Image, target_size: tuple = (224, 224)) -> Image.Image:
     """
     Resize image to target size.
 
@@ -97,14 +97,17 @@ def resize_image(image: Image.Image, target_size: tuple = (128, 128)) -> Image.I
 
 
 def normalize_rgb(
-    image: Union[Image.Image, np.ndarray], method: str = "0_1"
+    image: Union[Image.Image, np.ndarray], method: str = "imagenet"
 ) -> np.ndarray:
     """
-    Normalize RGB image to 0-1 range.
+    Normalize RGB image.
 
     Args:
         image: PIL Image or numpy array (H, W, 3) in 0-255 range
-        method: Normalization method ('0_1' or 'imagenet')
+        method: Normalization method:
+            - '0_1': scales pixel values to [0, 1]
+            - 'imagenet': scales to [0, 1] then standardizes using
+              ImageNet mean/std (produces values outside [0, 1])
 
     Returns:
         Normalized numpy array (H, W, 3) as float32
@@ -161,9 +164,9 @@ def prepare_tensor(
 
 def preprocess_image(
     image_input: Union[str, Path, Image.Image, np.ndarray, torch.Tensor],
-    target_size: tuple = (128, 128),
+    target_size: tuple = (224, 224),
     normalize: bool = True,
-    norm_method: str = "0_1",
+    norm_method: str = "imagenet",
     return_tensor: bool = True,
     add_batch_dim: bool = True,
     device: str = "cpu",
@@ -221,9 +224,9 @@ def preprocess_image(
 # Convenience functions for batch processing
 def preprocess_image_batch(
     image_inputs: list,
-    target_size: tuple = (128, 128),
+    target_size: tuple = (224, 224),
     normalize: bool = True,
-    norm_method: str = "0_1",
+    norm_method: str = "imagenet",
     device: str = "cpu",
 ) -> torch.Tensor:
     """

neon_tree_classification/models/lightning_modules.py

@@ -397,6 +397,7 @@ def __init__(
         class_weights: Optional[torch.Tensor] = None,
         log_images: bool = False,
         idx_to_label: Optional[Dict[int, str]] = None,
+        rgb_norm_method: str = "imagenet",
         **model_kwargs,
     ):
         """
@@ -413,6 +414,7 @@ def __init__(
             log_images: Whether to log sample images during validation
             idx_to_label: Optional label mapping {0: "Species1", 1: "Species2", ...}
                          for DeepForest CropModel compatibility
+            rgb_norm_method: Normalization method used during training ('imagenet' or '0_1')
             **model_kwargs: Additional arguments for model creation
         """
         # Create RGB model
@@ -432,6 +434,7 @@ def __init__(
 
         self.log_images = log_images
         self.logged_images_this_epoch = False
+        self.rgb_norm_method = rgb_norm_method
 
         # Set label_dict for DeepForest CropModel compatibility
         if idx_to_label is not None:
@@ -445,17 +448,24 @@ def _extract_modality_data(self, batch: Dict[str, torch.Tensor]) -> torch.Tensor
         return batch["rgb"]
 
     def normalize(self):
-        """Return normalization transform for DeepForest CropModel compatibility.
+        """Return normalization transform matching the training configuration.
 
-        Returns ImageNet normalization transform as used in training.
-        This method is required for DeepForest CropModel integration.
+        Required for DeepForest CropModel integration. Returns a transform
+        consistent with the rgb_norm_method used during training.
 
         Returns:
             torchvision.transforms.Normalize object
         """
-        return transforms.Normalize(
-            mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-        )
+        if self.rgb_norm_method == "imagenet":
+            return transforms.Normalize(
+                mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+            )
+        elif self.rgb_norm_method == "0_1":
+            # Scale to [0,1]: equivalent to dividing by 255 in ToTensor,
+            # represented as zero-mean, unit-std (no-op standardization)
+            return transforms.Normalize(mean=[0.0, 0.0, 0.0], std=[1.0, 1.0, 1.0])
+        else:
+            raise ValueError(f"Unknown rgb_norm_method: {self.rgb_norm_method}")
 
     def set_label_dict(self, idx_to_label: Dict[int, str]):
         """Set label dictionaries from idx_to_label mapping.

scripts/create_label_mappings.py

@@ -6,13 +6,12 @@
 from the training CSV and saves them as JSON files for use in inference.
 
 Usage:
-    python scripts/create_label_mappings.py
+    python scripts/create_label_mappings.py --csv_path path/to/labels.csv
 """
 
 import json
 import pandas as pd
 from pathlib import Path
-from collections import OrderedDict
 import sys
 
 # Add project root to path

scripts/upload_to_huggingface.py

@@ -235,6 +235,13 @@ def upload_to_huggingface(
         )
         sys.exit(1)
 
+    if not checkpoint_data["numeric_to_label_dict"]:
+        print(
+            "❌ Checkpoint missing numeric_to_label_dict! "
+            "Was the model trained with idx_to_label?"
+        )
+        sys.exit(1)
+
     num_classes = len(checkpoint_data["label_dict"])
     print(f"✅ Found {num_classes} classes in label_dict")