PytorchWildlife 1.2.0__tar.gz → 1.2.2__tar.gz

{PytorchWildlife-1.2.0/PytorchWildlife.egg-info → pytorchwildlife-1.2.2}/PKG-INFO

@@ -1,13 +1,12 @@
 Metadata-Version: 2.1
 Name: PytorchWildlife
-Version: 1.2.0
+Version: 1.2.2
 Summary: a PyTorch Collaborative Deep Learning Framework for Conservation.
 Home-page: https://github.com/microsoft/CameraTraps/
 Author: Andres Hernandez, Zhongqi Miao, Daniela Ruiz Lopez, Isai Daniel Chacon Silva
 Author-email: v-herandres@microsoft.com, zhongqimiao@microsoft.com, v-druizlopez@microsoft.com, v-ichaconsil@microsoft.com
 License: MIT
 Keywords: pytorch_wildlife,pytorch,wildlife,megadetector,conservation,animal,detection,classification
-Platform: UNKNOWN
 Classifier: Development Status :: 3 - Alpha
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
@@ -15,6 +14,20 @@ Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: torch
+Requires-Dist: torchvision
+Requires-Dist: torchaudio
+Requires-Dist: tqdm
+Requires-Dist: Pillow
+Requires-Dist: supervision==0.23.0
+Requires-Dist: gradio
+Requires-Dist: ultralytics
+Requires-Dist: chardet
+Requires-Dist: wget
+Requires-Dist: yolov5
+Requires-Dist: setuptools
+Requires-Dist: scikit-learn
+Requires-Dist: timm
 
 ![image](https://microsoft.github.io/CameraTraps/assets/Pytorch_Banner_transparentbk.png)
 
@@ -58,29 +71,60 @@ For those interested in accessing the previous MegaDetector repository, which ut
 
 ## 📣 Announcements
 
+### Pytorch-Wildlife Version 1.2.1
+
+#### SpeciesNet is available in Pytorch-Wildlife for testing! 
+- We have added SpeciesNet into our model zoo, which is compatible with all detection models provided by Pytorch-Wildlife. Please refer to [this document](https://github.com/microsoft/CameraTraps/blob/SppNet_TF/PytorchWildlife/models/classification/speciesnet_base/sppnet_readme.md) for more details!
+
+#### Deepfaune in Our Model Zoo!! 
+- We are excited to announce the release of the Deepfaune models—both the detector and classifier—in PyTorch-Wildlife, adding to our growing model zoo. A huge thank you to the Deepfaune team for your support! Deepfaune is one of the most comprehensive models focused on the European ecosystem for both detection and classification. It serves as a great complement to MegaDetector, which has primarily been trained on datasets from North America, South America, and Africa. The Deepfaune detector is also our first third-party camera trap detection model integrated into PyTorch-Wildlife!
+- To use the model, you just need to load them as any other Pytorch-Wildife models: 
+```
+detection_model = pw_detection.DeepfauneDetector(device=DEVICE)
+classification_model = pw_classification.DeepfauneClassifier(device=DEVICE)
+```
+- You can also use the `detection_classification_pipeline_demo.py` script in the demo folder to test the whole detection + classification pipeline. 
+- Please also take a look at the original [Deepfaune website](https://www.deepfaune.cnrs.fr/en/) and give them a star! 
+
+#### Deepfaune-New-England in Our Model Zoo Too!!
+- Besides the original Deepfaune mode, there is another fine-tuned Deepfaune model developed by USGS for the Northeastern NA area called Deepfaune-New-England (DFNE). It can also be loaded with `classification_model = pw_classification.DFNE(device=DEVICE)`
+- Please take a look at the orignal [DFNE repo](https://code.usgs.gov/vtcfwru/deepfaune-new-england/-/tree/main?ref_type=heads) and give them a star! 
+
 ### Pytorch-Wildlife Version 1.2.0
-- In this version of Pytorch-Wildlife, we are happy to release our [detection fine-tuning module](PW_FT_detection), with which users can fine-tune their own detection model from any released pre-trained MegaDetectorV6 models. Besides, this module also has functionalities that help users to prepare their datasets for the fine-tuning, just as our classification fine-tuning modules. For more details, please check the [readme](PW_FT_detection/README.md). Currently the fine-tuning is based on [Ultralytics](https://www.ultralytics.com/) with AGPL. We will release MIT versions in the future. Here is the [release page](https://github.com/microsoft/CameraTraps/releases).
-- We have also released additional MegaDetectorV6 models based on Yolo-v10 and RtDetr. We have skipped Yolo-v11 models because of limited performance and architectural gains. Most of t whe MIT and Apache versions have also finished training but are waiting for internal review before they can be released.
-- We have also updated our AI4G-Amazon model with bigger datasets and it has a better performance compared to previous iterations. Please feel free to test it or fine-tune on it. 
-- We will also make a new roadmap for 2025 in the next couple of updates.
+- [What's New](ANNOUNCEMENT.md)
 
 
-### :racing_car::dash::dash: MegaDetectorV6: SMALLER, BETTER, FASTER!  
-We have officially released our 6th version of MegaDetector, MegaDetectorV6! In the next generation of MegaDetector, we are focusing on computational efficiency, performance, mordernizing of model architectures, and licensing. We have trained multiple new models using different model architectures, including Yolo-v9, Yolo-v10, and RT-Detr for maximum user flexibility. We have a [rolling release schedule](#mag-model-zoo-and-release-schedules) for different versions of MegaDetectorV6.
 
-MegaDetectorV6 models are based on architectures optimized for performance and low-budget devices. For example, the MegaDetectorV6-Ultralytics-YoloV10-Compact (MDV6-yolov10-c) model only have ***2% of the parameters*** of the previous MegaDetectorV5 and still exhibits ***4% higher animal detection recall*** on our validation datasets. In the following figure, we can see the Performance to Parameter metric of each released MegaDetector model. All of the V6 models, extra large or compact, have at least 50% less parameters compared to MegaDetectorV5 but with much higher animal detection performance.
+### :racing_car::dash::dash: MegaDetectorV6: SMALLER, FASTER, BETTER!  
+We have officially released our 6th version of MegaDetector, MegaDetectorV6! In the next generation of MegaDetector, we are focusing on computational efficiency, performance, modernizing of model architectures, and licensing. We have trained multiple new models using different model architectures, including Yolo-v9, Yolo-v10, and RT-Detr for maximum user flexibility. We have a [rolling release schedule](#mag-model-zoo-and-release-schedules) for different versions of MegaDetectorV6.
 
-![image](assets/ParamPerf.png)
+>[!NOTE]
+> - Following our initial release, we’ve been delighted to see so many people explore our new models. We’d like to extend our heartfelt thanks to everyone who has shown interest in our latest models—your support means a great deal to us!
+> - That said, we’ve received a number of feedback comments highlighting a discrepancy between the reported performance (particularly MDV5) and the actual performance observed. We are actively investigating this issue and have identified a potential error or corruption in the validation data we used. For the time being, we’ll remove our current performance numbers from the model zoo for now to avoid confusion.
+> - We sincerely apologize for any confusion or inconvenience this may have caused. Our team is working diligently to address this matter, and we will update our experiments—and potentially retrain the model if data corruption is confirmed—as soon as possible. Thank you for your patience and understanding!
 
->[!TIP]
->From now on, we encourage our users to use MegaDetectorV6 as their default animal detection model and choose whichever model that fits the project needs. To reduce potential confusion, we have also standardized the model names into MDV6-Compact and MDV6-Extra for two model sizes using the same architecture. Learn how to use MegaDetectorV6 in our [image demo](demo/image_detection_demo_v6.ipynb) and [video demo](demo/video_detection_demo_v6.ipynb).
 
 
-### :bangbang: Model licensing  `(IMPORTANT!!)`
+MegaDetectorV6 models are based on architectures optimized for performance and low-budget devices. For example, the MegaDetectorV6-Ultralytics-YoloV10-Compact (MDV6-yolov10-c) model only have ***2% of the parameters*** of the previous MegaDetectorV5 and still exhibits comparable animal recall on our validation datasets. 
+
+<!-- In the following figure, we can see the Performance to Parameter metric of each released MegaDetector model. All of the V6 models, extra large or compact, have at least 50% less parameters compared to MegaDetectorV5 but with much higher animal detection performance. -->
+
+<!-- ![image](assets/ParamPerf.png) -->
+
+<!-- >[!TIP] -->
+<!-- >From now on, we encourage our users to use MegaDetectorV6 as their default animal detection model and choose whichever model that fits the project needs. To reduce potential confusion, we have also standardized the model names into MDV6-Compact and MDV6-Extra for two model sizes using the same architecture. Learn how to use MegaDetectorV6 in our [image demo](demo/image_detection_demo_v6.ipynb) and [video demo](demo/video_detection_demo_v6.ipynb). -->
 
-The **Pytorch-Wildlife** package is under MIT, however some of the models in the model zoo are not. For example, MegaDetectorV5, which is trained using the Ultralytics package, is under AGPL-3.0, and is not for closed-source comercial uses.
-> [!IMPORTANT]
-> THIS IS TRUE TO ALL EXISTING MEGADETECTORV5 MODELS IN ALL EXISTING FORKS THAT ARE TRAINED USING YOLOV5, AN ULTRALYTICS-DEVELOPED MODEL.
+
+### :bangbang: Model licensing 
+
+The **Pytorch-Wildlife** package is under MIT, however some of the models in the model zoo are not. For example, MegaDetectorV5, which is trained using the Ultralytics package, a package under AGPL-3.0, and is not for closed-source commercial uses if they are using updated 'ultralytics' packages. 
+
+There may be a confusion because YOLOv5 was initially released before the establishment of the AGPL-3.0 license. According to the official [Ultralytics-Yolov5](https://github.com/ultralytics/yolov5) package, it is under AGPL-3.0 now, and the maintainers have discussed how their licensing policy has evolved over time in their issues section. 
+
+<!-- We aim to prevent any confusion or potential issues for our users. -->
+
+<!-- > [!IMPORTANT]
+> THIS IS TRUE TO ALL EXISTING MEGADETECTORV5 MODELS IN ALL EXISTING FORKS THAT ARE TRAINED USING YOLOV5, AN ULTRALYTICS-DEVELOPED MODEL. -->
 
 We want to make Pytorch-Wildlife a platform where different models with different licenses can be hosted and want to enable different use cases. To reduce user confusions, in our [model zoo](#mag-model-zoo-and-release-schedules) section, we list all existing and planed future models in our model zoo, their corresponding license, and release schedules. 
 
@@ -89,7 +133,22 @@ In addition, since the **Pytorch-Wildlife** package is under MIT, all the utilit
 ### :mag: Model Zoo and Release Schedules
 
 #### MegaDetectors 
-|Models|Version Names|Licence|Release|Parameters (M)|mAP<sup>val<br>50-95|Animal Recall|
+|Models|Version Names|Licence|Release|Parameters (M)|
+|---|---|---|---|---|
+|MegaDetectorV5|-|AGPL-3.0|Released|121|
+|MegaDetectorV6-Ultralytics-YoloV9-Compact|MDV6-yolov9-c|AGPL-3.0|Released|25.5|
+|MegaDetectorV6-Ultralytics-YoloV9-Extra|MDV6-yolov9-e|AGPL-3.0|Released|58.1|
+|MegaDetectorV6-Ultralytics-YoloV10-Compact (even smaller and no NMS)|MDV6-yolov10-c|AGPL-3.0|Released|2.3|
+|MegaDetectorV6-Ultralytics-YoloV10-Extra (extra large model and no NMS)|MDV6-yolov10-c|AGPL-3.0|Released|29.5|
+|MegaDetectorV6-Ultralytics-RtDetr-Compact|MDV6-redetr-c|AGPL-3.0|Released|31.9|
+|MegaDetectorV6-Ultralytics-YoloV11-Compact|-|AGPL-3.0|Will Not Release|2.6|
+|MegaDetectorV6-Ultralytics-YoloV11-Extra|-|AGPL-3.0|Will Not Release|56.9|
+|MegaDetectorV6-MIT-YoloV9-Compact|MDV6-mit-yolov9-c|MIT|Training|9.7|
+|MegaDetectorV6-MIT-YoloV9-Extra|MDV6-mit-yolov9-c|MIT|Training|51|
+|MegaDetectorV6-Apache-RTDetr-Compact|MDV6-apa-redetr-c|Apache|Training|20|
+|MegaDetectorV6-Apache-RTDetr-Extra|MDV6-apa-redetr-c|Apache|Training|76|
+
+<!-- |Models|Version Names|Licence|Release|Parameters (M)|mAP<sup>val<br>50-95|Animal Recall|
 |---|---|---|---|---|---|---|
 |MegaDetectorV5|-|AGPL-3.0|Released|121|74.7|74.9|
 |MegaDetectorV6-Ultralytics-YoloV9-Compact|MDV6-yolov9-c|AGPL-3.0|Released|25.5|73.8|82.6|
@@ -102,11 +161,17 @@ In addition, since the **Pytorch-Wildlife** package is under MIT, all the utilit
 |MegaDetectorV6-MIT-YoloV9-Compact|MDV6-mit-yolov9-c|MIT|MDV6-mit-yolov9-c|February 2025|9.7|73.84|-|
 |MegaDetectorV6-MIT-YoloV9-Extra|MDV6-mit-yolov9-c|MIT|February 2025|51|Training|Training|
 |MegaDetectorV6-Apache-RTDetr-Compact|MDV6-apa-redetr-c|Apache|February 2025|20|76.3|-|
-|MegaDetectorV6-Apache-RTDetr-Extra|MDV6-apa-redetr-c|Apache|February 2025|76|80.8|-|
+|MegaDetectorV6-Apache-RTDetr-Extra|MDV6-apa-redetr-c|Apache|February 2025|76|80.8|-| -->
+
+> [!TIP]
+> We are specifically reporting `Animal Recall` as our primary performance metric, even though it is not commonly used in traditional object detection studies, which typically focus on balancing overall model performance. For MegaDetector, our goal is to optimize for animal recall—in other words, minimizing false negative detections of animals or, more simply, ensuring our model misses as few animals as possible. While this may result in a higher false positive rate, we rely on downstream classification models to further filter the detected objects. We believe this approach is more practical for real-world animal monitoring scenarios.
+
+ 
 
 #### Other detection models 
 |Models|Version Names|Licence|Release|Reference|
 |---|---|---|---|---|
+|Deepfaune-detection|-|CC BY-SA 4.0|Released|[Deepfaune](https://www.deepfaune.cnrs.fr/en/)|
 |HerdNet-general|general|CC BY-NC-SA-4.0|Released|[Alexandre et. al. 2023](https://github.com/Alexandre-Delplanque/HerdNet)|
 |HerdNet-ennedi|ennedi|CC BY-NC-SA-4.0|Released|[Alexandre et. al. 2023](https://github.com/Alexandre-Delplanque/HerdNet)|
 |MegaDetector-Overhead|-|MIT|Mid 2025|-|
@@ -119,6 +184,8 @@ In addition, since the **Pytorch-Wildlife** package is under MIT, all the utilit
 |AI4G-Amazon-V1|v1|MIT|Released|
 |AI4G-Amazon-V2|v2|MIT|Released|
 |AI4G-Serengeti|-|MIT|Released|
+|Deepfaune-classification|v1.3|CC BY-SA 4.0|Released|[Deepfaune](https://www.deepfaune.cnrs.fr/en/)|
+|Deepfaune-New-England|v1.0|CC0 1.0 Universal|Released|[Deepfaune-New-England](https://code.usgs.gov/vtcfwru/deepfaune-new-england)|
 
 >[!TIP]
 >Some models, such as MegaDetectorV6, HerdNet, and AI4G-Amazon, have different versions, and they are loaded by their corresponding version names. Here is an example: `detection_model = pw_detection.MegaDetectorV6(version="MDV6-yolov10-e")`.
@@ -214,8 +281,8 @@ Let's shape the future of wildlife research, together! 🙌
 *Credits to the Agency for Regulation and Control of Biosecurity and Quarantine for Galápagos (ABG), Ecuador.*
 
 
-## 🤜🤛 Collaboration with EcoAssist!
-We are thrilled to announce our collaboration with [EcoAssist](https://addaxdatascience.com/ecoassist/#spp-models)---a powerful user interface software that enables users to directly load models from the PyTorch-Wildlife model zoo for image analysis on local computers. With EcoAssist, you can now utilize MegaDetectorV5 and the classification models---AI4GAmazonRainforest and AI4GOpossum---for automatic animal detection and identification, alongside a comprehensive suite of pre- and post-processing tools. This partnership aims to enhance the overall user experience with PyTorch-Wildlife models for a general audience. We will work closely to bring more features together for more efficient and effective wildlife analysis in the future.
+## 🤜🤛 Collaboration with AddaxAI (formerly EcoAssist)!
+We are thrilled to announce our collaboration with [AddaxAI](https://addaxdatascience.com/addaxai/#spp-models)---a powerful user interface software that enables users to directly load models from the PyTorch-Wildlife model zoo for image analysis on local computers. With AddaxAI, you can now utilize MegaDetectorV5 and the classification models---AI4GAmazonRainforest and AI4GOpossum---for automatic animal detection and identification, alongside a comprehensive suite of pre- and post-processing tools. This partnership aims to enhance the overall user experience with PyTorch-Wildlife models for a general audience. We will work closely to bring more features together for more efficient and effective wildlife analysis in the future.
 
 
 ## :fountain_pen: Cite us!
@@ -393,5 +460,3 @@ Protected Areas Unit, Canadian Wildlife Service
 >[!IMPORTANT]
 >If you would like to be added to this list or have any questions regarding MegaDetector and Pytorch-Wildlife, please [email us](zhongqimiao@microsoft.com) or join us in our Discord channel: [![](https://img.shields.io/badge/any_text-Join_us!-blue?logo=discord&label=PytorchWildife)](https://discord.gg/TeEVxzaYtm)
 
-
-

{PytorchWildlife-1.2.0 → pytorchwildlife-1.2.2}/PytorchWildlife/data/datasets.py

@@ -25,7 +25,7 @@ def is_image_file(filename: str) -> bool:
     """Checks if a file is an allowed image extension."""  
     return has_file_allowed_extension(filename, IMG_EXTENSIONS) 
 
-class DetectionImageFolder(Dataset):
+class ImageFolder(Dataset):
     """
     A PyTorch Dataset for loading images from a specified directory.
     Each item in the dataset is a tuple containing the image data, 
@@ -40,11 +40,49 @@ class DetectionImageFolder(Dataset):
             image_dir (str): Path to the directory containing the images.
             transform (callable, optional): Optional transform to be applied on the image.
         """
-        super(DetectionImageFolder, self).__init__()
+        super(ImageFolder, self).__init__()
         self.image_dir = image_dir
         self.transform = transform
         self.images = [os.path.join(dp, f) for dp, dn, filenames in os.walk(image_dir) for f in filenames if is_image_file(f)] # dp: directory path, dn: directory name, f: filename
 
+    def __getitem__(self, idx):
+        """
+        Retrieves an image from the dataset.
+
+        Parameters:
+            idx (int): Index of the image to retrieve.
+
+        Returns:
+            tuple: Contains the image data, the image's path, and its original size.
+        """
+        pass
+    
+    def __len__(self):
+        """
+        Returns the total number of images in the dataset.
+
+        Returns:
+            int: Total number of images.
+        """
+        return len(self.images)
+
+class ClassificationImageFolder(ImageFolder):
+    """
+    A PyTorch Dataset for loading images from a specified directory.
+    Each item in the dataset is a tuple containing the image data, 
+    the image's path, and the original size of the image.
+    """
+
+    def __init__(self, image_dir, transform=None):
+        """
+        Initializes the dataset.
+
+        Parameters:
+            image_dir (str): Path to the directory containing the images.
+            transform (callable, optional): Optional transform to be applied on the image.
+        """
+        super(ClassificationImageFolder, self).__init__(image_dir, transform)
+
     def __getitem__(self, idx):
         """
         Retrieves an image from the dataset.
@@ -60,22 +98,54 @@ class DetectionImageFolder(Dataset):
 
         # Load and convert image to RGB
         img = Image.open(img_path).convert("RGB")
-        img_size_ori = img.size[::-1]
         
         # Apply transformation if specified
         if self.transform:
             img = self.transform(img)
 
-        return img, img_path, torch.tensor(img_size_ori)
-    
-    def __len__(self):
+        return img, img_path
+
+
+class DetectionImageFolder(ImageFolder):
+    """
+    A PyTorch Dataset for loading images from a specified directory.
+    Each item in the dataset is a tuple containing the image data, 
+    the image's path, and the original size of the image.
+    """
+
+    def __init__(self, image_dir, transform=None):
         """
-        Returns the total number of images in the dataset.
+        Initializes the dataset.
+
+        Parameters:
+            image_dir (str): Path to the directory containing the images.
+            transform (callable, optional): Optional transform to be applied on the image.
+        """
+        super(DetectionImageFolder, self).__init__(image_dir, transform)
+
+    def __getitem__(self, idx):
+        """
+        Retrieves an image from the dataset.
+
+        Parameters:
+            idx (int): Index of the image to retrieve.
 
         Returns:
-            int: Total number of images.
+            tuple: Contains the image data, the image's path, and its original size.
         """
-        return len(self.images)
+        # Get image filename and path
+        img_path = self.images[idx]
+
+        # Load and convert image to RGB
+        img = Image.open(img_path).convert("RGB")
+        img_size_ori = img.size[::-1]
+        
+        # Apply transformation if specified
+        if self.transform:
+            img = self.transform(img)
+
+        return img, img_path, torch.tensor(img_size_ori)
+    
 
 # TODO: Under development for efficiency improvement
 class DetectionCrops(Dataset):

{PytorchWildlife-1.2.0 → pytorchwildlife-1.2.2}/PytorchWildlife/data/transforms.py

@@ -130,7 +130,7 @@ class Classification_Inference_Transform:
     mean = [0.485, 0.456, 0.406]
     std = [0.229, 0.224, 0.225]
 
-    def __init__(self, target_size=224):
+    def __init__(self, target_size=224, **kwargs):
         """
         Initializes the transform.
 
@@ -139,7 +139,8 @@ class Classification_Inference_Transform:
         """
         # Define the sequence of transformations
         self.trans = transforms.Compose([
-            transforms.Resize((target_size, target_size)),
+            # transforms.Resize((target_size, target_size)),
+            transforms.Resize((target_size, target_size), **kwargs),
             transforms.ToTensor(),
             transforms.Normalize(self.mean, self.std)
         ])

pytorchwildlife-1.2.2/PytorchWildlife/models/classification/__init__.py

@@ -0,0 +1,3 @@
+from .resnet_base import *
+from .timm_base import *
+from .base_classifier import *

pytorchwildlife-1.2.2/PytorchWildlife/models/classification/base_classifier.py

@@ -0,0 +1,28 @@
+
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License.
+
+import torch.nn as nn
+
+# Making the PlainResNetInference class available for import from this module
+__all__ = ["BaseClassifierInference"]
+
+class BaseClassifierInference(nn.Module):
+    """
+    Inference module for the PlainResNet Classifier.
+    """
+    def __init__(self):
+        super(BaseClassifierInference, self).__init__()
+        pass
+
+    def results_generation(self):
+        pass
+
+    def forward(self):
+        pass
+
+    def single_image_classification(self):
+        pass
+
+    def batch_image_classification(self):
+        pass

{PytorchWildlife-1.2.0/PytorchWildlife/models/classification/resnet → pytorchwildlife-1.2.2/PytorchWildlife/models/classification/resnet_base}/base_classifier.py

@@ -10,8 +10,11 @@ import torch
 import torch.nn as nn
 from torchvision.models.resnet import BasicBlock, Bottleneck, ResNet
 from torch.hub import load_state_dict_from_url
+from torch.utils.data import DataLoader
 
+from ..base_classifier import BaseClassifierInference 
 from ....data import transforms as pw_trans
+from ....data import datasets as pw_data 
 
 # Making the PlainResNetInference class available for import from this module
 __all__ = ["PlainResNetInference"]
@@ -97,10 +100,11 @@ class PlainResNetClassifier(nn.Module):
         print("unused_keys:", sorted(list(unused_keys)))
 
 
-class PlainResNetInference(nn.Module):
+class PlainResNetInference(BaseClassifierInference):
     """
     Inference module for the PlainResNet Classifier.
     """
+    IMAGE_SIZE = None
     def __init__(self, num_cls=36, num_layers=50, weights=None, device="cpu", url=None, transform=None):
         super(PlainResNetInference, self).__init__()
         self.device = device
@@ -118,7 +122,7 @@ class PlainResNetInference(nn.Module):
         if transform:
             self.transform = transform
         else:
-            self.transform = pw_trans.Classification_Inference_Transform(target_size=224)
+            self.transform = pw_trans.Classification_Inference_Transform(target_size=self.IMAGE_SIZE)
 
     def results_generation(self, logits, img_id, id_strip=None):
         """
@@ -148,10 +152,28 @@ class PlainResNetInference(nn.Module):
         logits = self.forward(img.unsqueeze(0).to(self.device))
         return self.results_generation(logits.cpu(), [img_id], id_strip=id_strip)[0]
 
-    def batch_image_classification(self, dataloader, id_strip=None):
+    def batch_image_classification(self, data_path=None, det_results=None, id_strip=None):
         """
         Process a batch of images for classification.
         """
+
+        if data_path:
+            dataset = pw_data.ImageFolder(
+                data_path,
+                transform=self.transform,
+                path_head='.'
+            )
+        elif det_results:
+            dataset = pw_data.DetectionCrops(
+                det_results,
+                transform=self.transform,
+                path_head='.'
+            )
+        else:
+            raise Exception("Need data for inference.")
+
+        dataloader = DataLoader(dataset, batch_size=32, shuffle=False, 
+                                pin_memory=True, num_workers=4, drop_last=False)
         total_logits = []
         total_paths = []
 

pytorchwildlife-1.2.2/PytorchWildlife/models/classification/timm_base/DFNE.py

@@ -0,0 +1,56 @@
+"""
+This is a Pytorch-Wildlife loader for the Deepfaune-New-England classifier.
+The original model is available at: https://code.usgs.gov/vtcfwru/deepfaune-new-england/-/tree/main?ref_type=heads
+Licence: CC0 1.0 Universal 
+Copyright USGS 2024
+laurence.clarfeld@uvm.edu
+"""
+
+# Import libraries
+
+from .base_classifier import TIMM_BaseClassifierInference
+
+__all__ = [
+    "DFNE"
+]
+
+class DFNE(TIMM_BaseClassifierInference):
+    """
+    Base detector class for dinov2 classifier. This class provides utility methods
+    for loading the model, performing single and batch image classifications, and 
+    formatting results. Make sure the appropriate file for the model weights has been 
+    downloaded to the "models" folder before running DFNE.
+    """
+    BACKBONE = "vit_large_patch14_dinov2.lvd142m"
+    MODEL_NAME = "dfne_weights_v1_0.pth"
+    IMAGE_SIZE = 182
+    CLASS_NAMES = {
+                0: "American Marten",
+                1: "Bird sp.",
+                2: "Black Bear",
+                3: "Bobcat",
+                4: "Coyote",
+                5: "Domestic Cat",
+                6: "Domestic Cow",
+                7: "Domestic Dog",
+                8: "Fisher",
+                9: "Gray Fox",
+                10: "Gray Squirrel",
+                11: "Human",
+                12: "Moose",
+                13: "Mouse sp.",
+                14: "Opossum",
+                15: "Raccoon",
+                16: "Red Fox",
+                17: "Red Squirrel",
+                18: "Skunk",
+                19: "Snowshoe Hare",
+                20: "White-tailed Deer",
+                21: "Wild Boar",
+                22: "Wild Turkey",
+                23: "no-species"
+            }
+
+    def __init__(self, weights=None, device="cpu", transform=None):
+        url = 'https://prod-is-usgs-sb-prod-publish.s3.amazonaws.com/67ae17fcd34e3f09c0e0f002/dfne_weights_v1_0.pth'
+        super(DFNE, self).__init__(weights=weights, device=device, url=url, transform=transform, weights_key='model_state_dict')    

pytorchwildlife-1.2.2/PytorchWildlife/models/classification/timm_base/Deepfaune.py

@@ -0,0 +1,47 @@
+"""
+This is a Pytorch-Wildlife loader for the Deepfaune classifier.
+The original Deepfaune model is available at: https://www.deepfaune.cnrs.fr/en/
+Licence: CC BY-SA 4.0
+Copyright CNRS 2024
+simon.chamaille@cefe.cnrs.fr; vincent.miele@univ-lyon1.fr
+"""
+
+# Import libraries
+
+from torchvision.transforms.functional import InterpolationMode
+from .base_classifier import TIMM_BaseClassifierInference
+from ....data import transforms as pw_trans
+
+__all__ = [
+    "DeepfauneClassifier"
+]
+
+class DeepfauneClassifier(TIMM_BaseClassifierInference):
+    """
+    Base detector class for dinov2 classifier. This class provides utility methods
+    for loading the model, performing single and batch image classifications, and 
+    formatting results. Make sure the appropriate file for the model weights has been 
+    downloaded to the "models" folder before running DFNE.
+    """
+    BACKBONE = "vit_large_patch14_dinov2.lvd142m"
+    MODEL_NAME = "deepfaune-vit_large_patch14_dinov2.lvd142m.v3.pt"
+    IMAGE_SIZE = 182
+    CLASS_NAMES={
+        'fr': ['bison', 'blaireau', 'bouquetin', 'castor', 'cerf', 'chamois', 'chat', 'chevre', 'chevreuil', 'chien', 'daim', 'ecureuil', 'elan', 'equide', 'genette', 'glouton', 'herisson', 'lagomorphe', 'loup', 'loutre', 'lynx', 'marmotte', 'micromammifere', 'mouflon', 'mouton', 'mustelide', 'oiseau', 'ours', 'ragondin', 'raton laveur', 'renard', 'renne', 'sanglier', 'vache'],
+        'en': ['bison', 'badger', 'ibex', 'beaver', 'red deer', 'chamois', 'cat', 'goat', 'roe deer', 'dog', 'fallow deer', 'squirrel', 'moose', 'equid', 'genet', 'wolverine', 'hedgehog', 'lagomorph', 'wolf', 'otter', 'lynx', 'marmot', 'micromammal', 'mouflon', 'sheep', 'mustelid', 'bird', 'bear', 'nutria', 'raccoon', 'fox', 'reindeer', 'wild boar', 'cow'],
+        'it': ['bisonte', 'tasso', 'stambecco', 'castoro', 'cervo', 'camoscio', 'gatto', 'capra', 'capriolo', 'cane', 'daino', 'scoiattolo', 'alce', 'equide', 'genetta', 'ghiottone', 'riccio', 'lagomorfo', 'lupo', 'lontra', 'lince', 'marmotta', 'micromammifero', 'muflone', 'pecora', 'mustelide', 'uccello', 'orso', 'nutria', 'procione', 'volpe', 'renna', 'cinghiale', 'mucca'],
+        'de': ['Bison', 'Dachs', 'Steinbock', 'Biber', 'Rothirsch', 'Gämse', 'Katze', 'Ziege', 'Rehwild', 'Hund', 'Damwild', 'Eichhörnchen', 'Elch', 'Equide', 'Ginsterkatze', 'Vielfraß', 'Igel', 'Lagomorpha', 'Wolf', 'Otter', 'Luchs', 'Murmeltier', 'Kleinsäuger', 'Mufflon', 'Schaf', 'Marder', 'Vogel', 'Bär', 'Nutria', 'Waschbär', 'Fuchs', 'Rentier', 'Wildschwein', 'Kuh'],
+    }
+
+
+    def __init__(self, weights=None, device="cpu", transform=None, class_name_lang='en'):
+        url = 'https://pbil.univ-lyon1.fr/software/download/deepfaune/v1.3/deepfaune-vit_large_patch14_dinov2.lvd142m.v3.pt'
+        self.CLASS_NAMES = {i: c for i, c in enumerate(self.CLASS_NAMES[class_name_lang])}
+        if transform is None:
+            transform = pw_trans.Classification_Inference_Transform(target_size=self.IMAGE_SIZE, 
+                                                                    interpolation=InterpolationMode.BICUBIC, 
+                                                                    max_size=None,
+                                                                    antialias=None)
+        super(DeepfauneClassifier, self).__init__(weights=weights, device=device, url=url, transform=transform,
+                                                  weights_key='state_dict', weights_prefix='base_model.')
+        

pytorchwildlife-1.2.2/PytorchWildlife/models/classification/timm_base/__init__.py

@@ -0,0 +1,3 @@
+from .base_classifier import *
+from .Deepfaune import *
+from .DFNE import *