added identification benchmark

.gitignore

@@ -1,4 +1,5 @@
 *.png
+*.jpg
 *.txt
 *.out
 *.pt
@@ -10,4 +11,6 @@ object_detector_benchmark/yolo_benchmark/*
 object_detector_benchmark/8_calves_arrow/
 object_detector_benchmark/8_calves_coco/
 object_detector_benchmark/transformer_benchmark/runs
-object_detector_benchmark/transformer_benchmark/__pycache__
+*__pycache__
+!requirement.txt
+*.mdb

README.md

@@ -66,11 +66,14 @@ df = pd.read_pickle("pmfeed_4_3_16_bboxes_and_labels.pkl")
 
 ## Usage
 ### Dataset Download:
+Step 1: install conda environment from
+`requirement.txt`
 
-Step 1: install git-lfs:
+
+Step 2: install git-lfs:
 `git lfs install`
 
-Step 2: 
+Step 3: 
 `git clone [email protected]:datasets/tonyFang04/8-calves`
 
 ### Object Detection
@@ -86,14 +89,13 @@ Step 2:
 | Test       | 67,760 | Final evaluation |  
 
 ### Benchmarking YOLO Models:
-Step 1: install albumentations. Check out [Albumentations' website](https://www.albumentations.ai/docs/) for more information.
 
-Step 2: 
+Step 1: 
 `cd 8-calves/object_detector_benchmark`. Run
 `./create_yolo_dataset.sh` and
 `create_yolo_testset.py`. This creates a YOLO dataset with the 500/100/67760 train/val/test split recommended above.
 
-Step 3: install ultralytics. Check out [Ultralytics's website](https://github.com/ultralytics/ultralytics) for more information. Find the `Albumentations` class in the `data/augment.py` file in ultralytics source code. And replace the default transforms to:
+Step 2: find the `Albumentations` class in the `data/augment.py` file in ultralytics source code. And replace the default transforms to:
 
 ```
 # Transforms
@@ -109,8 +111,8 @@ T = [
 ]
 ```
 
-Step 4:
-run the yolo detectors following the following steps:
+Step 3:
+run the yolo detectors following the following commands:
 
 ```
 cd yolo_benchmark
@@ -120,6 +122,22 @@ Model_Name=yolov9t
 yolo cfg=experiment.yaml model=$Model_Name.yaml name=$Model_Name
 ```
 
+### Benchmark Transformer Based Models:
+
+Step 1: run the following commands to load the data into yolo format, then into coco, then into arrow:
+```
+cd 8-calves/object_detector_benchmark
+./create_yolo_dataset.sh
+python create_yolo_testset.py
+python yolo_to_coco.py
+python data_wrangling.py
+```
+
+Step 2: run the following commands to train:
+```
+cd transformer_benchmark
+python train.py --config Configs/conditional_detr.yaml
+```
 
 ### Identity Classification
 - Use `tracklet_id` (1-8) from the PKL file as labels.  

identification_benchmark/big_model_inference/data_loading.py

@@ -0,0 +1,143 @@
+import os
+import lmdb
+import io
+import re
+from PIL import Image
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+import unittest
+from tqdm import tqdm
+torch.multiprocessing.set_sharing_strategy('file_system')
+
+
+class LMDBImageDataset(Dataset):
+    def __init__(self, lmdb_path, transform=None, limit=None):
+        """
+        Args:
+            lmdb_path (str): Path to the LMDB directory.
+            transform (callable, optional): Optional transform to be applied on an image.
+            limit (int or float, optional): If a float between 0 and 1, keeps that fraction of keys.
+                                              If an int, keeps that many keys.
+        """
+        # Open the LMDB environment in read-only mode.
+        self.env = lmdb.open(lmdb_path, readonly=True, lock=False, readahead=False)
+        self.transform = transform
+        
+        # Retrieve all keys from the LMDB database.
+        with self.env.begin() as txn:
+            keys = [key.decode('utf-8') for key, _ in txn.cursor()]
+        
+        # Define a sort key function that extracts frame number and cow id from the filename.
+        def sort_key(filename):
+            # Expected pattern: "pmfeed_4_3_16_frame_10000_cow_1.jpg"
+            match = re.search(r'frame_(\d+)_cow_(\d+)', filename)
+            if match:
+                frame = int(match.group(1))
+                cow = int(match.group(2))
+                return (frame, cow)
+            return (float('inf'), float('inf'))
+        
+        # Sort the keys using the defined sort key function.
+        keys = sorted(keys, key=sort_key)
+        
+        # Apply the limit if provided.
+        if limit is not None:
+            if isinstance(limit, float):
+                if 0 <= limit <= 1:
+                    cutoff = int(len(keys) * limit)
+                    keys = keys[:cutoff]
+                else:
+                    raise ValueError("If limit is a float, it must be between 0 and 1.")
+            elif isinstance(limit, int):
+                keys = keys[:limit]
+            else:
+                raise TypeError("limit must be either a float or an integer.")
+        
+        self.keys = keys
+
+    def __getitem__(self, index):
+        # Get the key and image data
+        key_str = self.keys[index]
+        key = key_str.encode('utf-8')
+        with self.env.begin() as txn:
+            image_bytes = txn.get(key)
+        
+        # Convert binary image data to a PIL Image.
+        image = Image.open(io.BytesIO(image_bytes)).convert('RGB')
+        
+        if self.transform:
+            image = self.transform(image)
+        
+        # Extract the cow id from the filename.
+        match = re.search(r'frame_(\d+)_cow_(\d+)', key_str)
+        if match:
+            cow_id = int(match.group(2))
+        else:
+            cow_id = -1  # Use -1 or any default value if not found
+        
+        return image, cow_id
+
+    def __len__(self):
+        return len(self.keys)
+
+
+class TestLMDBImageDataset(unittest.TestCase):
+    def test_dataset_length(self):
+        # Example transform: resize and convert to tensor.
+        transform = transforms.Compose([
+            transforms.Resize((256, 256)),
+            transforms.ToTensor(),
+        ])
+
+        # Path to your LMDB directory.
+        lmdb_path = '../lmdb_all_crops_pmfeed_4_3_16'
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform, limit=20)
+        self.assertEqual(len(dataset), 20)
+        self.assertEqual(dataset.keys, ['pmfeed_4_3_16_frame_1_cow_1.jpg', 'pmfeed_4_3_16_frame_1_cow_2.jpg', 'pmfeed_4_3_16_frame_1_cow_3.jpg', 'pmfeed_4_3_16_frame_1_cow_4.jpg', 'pmfeed_4_3_16_frame_1_cow_5.jpg', 'pmfeed_4_3_16_frame_1_cow_6.jpg', 'pmfeed_4_3_16_frame_1_cow_7.jpg', 'pmfeed_4_3_16_frame_1_cow_8.jpg', 'pmfeed_4_3_16_frame_2_cow_1.jpg', 'pmfeed_4_3_16_frame_2_cow_2.jpg', 'pmfeed_4_3_16_frame_2_cow_3.jpg', 'pmfeed_4_3_16_frame_2_cow_4.jpg', 'pmfeed_4_3_16_frame_2_cow_5.jpg', 'pmfeed_4_3_16_frame_2_cow_6.jpg', 'pmfeed_4_3_16_frame_2_cow_7.jpg', 'pmfeed_4_3_16_frame_2_cow_8.jpg', 'pmfeed_4_3_16_frame_3_cow_1.jpg', 'pmfeed_4_3_16_frame_3_cow_2.jpg', 'pmfeed_4_3_16_frame_3_cow_3.jpg', 'pmfeed_4_3_16_frame_3_cow_4.jpg'])
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform, limit=100)
+        self.assertEqual(len(dataset), 100)
+        self.assertEqual(dataset.keys[-10:], ['pmfeed_4_3_16_frame_12_cow_3.jpg', 'pmfeed_4_3_16_frame_12_cow_4.jpg', 'pmfeed_4_3_16_frame_12_cow_5.jpg', 'pmfeed_4_3_16_frame_12_cow_6.jpg', 'pmfeed_4_3_16_frame_12_cow_7.jpg', 'pmfeed_4_3_16_frame_12_cow_8.jpg', 'pmfeed_4_3_16_frame_13_cow_1.jpg', 'pmfeed_4_3_16_frame_13_cow_2.jpg', 'pmfeed_4_3_16_frame_13_cow_3.jpg', 'pmfeed_4_3_16_frame_13_cow_4.jpg'])
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform)
+        self.assertEqual(len(dataset), 537908)
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform, limit=0.5)
+        self.assertEqual(len(dataset), 268954)
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform, limit=0.3)
+        self.assertEqual(len(dataset), 161372)
+        
+    def test_data_loading(self):
+        # Example transform: resize and convert to tensor.
+        transform = transforms.Compose([
+            transforms.Resize((256, 256)),
+            transforms.ToTensor(),
+        ])
+
+        # Path to your LMDB directory.
+        lmdb_path = '../lmdb_all_crops_pmfeed_4_3_16'
+
+        # Create the dataset:
+        # For example, if you want to keep the first 20 keys:
+        dataset = LMDBImageDataset(lmdb_path=lmdb_path, transform=transform)
+        # Or, if you want to keep the first 50% of the keys:
+        # Create a DataLoader.
+        dataloader = DataLoader(
+            dataset, 
+            batch_size=256, 
+            shuffle=False, 
+            num_workers=8,
+        )
+
+        # Example: Iterate over one batch.
+        ground_truths = []
+        for images, cow_ids in tqdm(dataloader, unit='batch'):
+            # print(images.shape)  # e.g., torch.Size([32, 3, 256, 256])
+            # print(cow_ids)       # Tensor of cow IDs corresponding to each image.
+            ground_truths.append(cow_ids)
+
+        ground_truths = torch.cat(ground_truths, dim=0)
+        self.assertEqual(len(ground_truths), 537908)
+        self.assertEqual(set(ground_truths.tolist()), {1, 2, 3, 4, 5, 6, 7, 8})
+        
+
+if __name__ == "__main__":
+    unittest.main()

identification_benchmark/big_model_inference/inference_resnet.py

@@ -0,0 +1,67 @@
+import torch
+from torchvision import transforms, models
+from data_loading import LMDBImageDataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+import argparse
+
+torch.multiprocessing.set_sharing_strategy('file_system')
+
+def main():
+    # Parse command line arguments.
+    parser = argparse.ArgumentParser(description="Compute ResNet embeddings")
+    parser.add_argument('--resnet_type', type=str, default='resnet152',
+                        help="Type of ResNet model to use (e.g., resnet18, resnet34, resnet50, resnet101, resnet152)")
+    parser.add_argument('--lmdb_path', type=str, default='../lmdb_all_crops_pmfeed_4_3_16',
+                        help="Path to the LMDB image dataset")
+    args = parser.parse_args()
+
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+    ])
+
+    # Create the dataset and dataloader.
+    dataset = LMDBImageDataset(
+        lmdb_path=args.lmdb_path, 
+        transform=transform, 
+        limit=None
+    )
+    dataloader = DataLoader(
+        dataset, 
+        batch_size=128, 
+        shuffle=False, 
+        num_workers=8,
+    )
+
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    
+    # Dynamically load the specified ResNet model.
+    resnet_constructor = getattr(models, args.resnet_type)
+    model = resnet_constructor(weights='IMAGENET1K_V1')
+    # Remove the last fully-connected layer to obtain embeddings.
+    model = list(model.children())[:-1]
+    model = torch.nn.Sequential(*model)
+    model.to(device)
+    model.eval()
+
+    all_embeddings = []
+    all_cow_ids = []
+
+    # Loop through the dataset and compute embeddings.
+    with torch.no_grad():
+        for images, cow_ids in tqdm(dataloader, unit='batch'):
+            images = images.to(device)
+            image_features = model(images)
+            image_features = image_features.squeeze()
+            all_embeddings.append(image_features.cpu())
+            all_cow_ids.append(cow_ids)
+
+    # Concatenate and save all embeddings.
+    embeddings = torch.cat(all_embeddings, dim=0)
+    torch.save(embeddings, f"{args.resnet_type}_embeddings.pt")
+    all_cow_ids = torch.cat(all_cow_ids, dim=0)
+    torch.save(all_cow_ids, f"all_cow_ids.pt")
+
+if __name__ == '__main__':
+    main()

identification_benchmark/big_model_inference/inference_transformers.py

@@ -0,0 +1,98 @@
+import torch
+import argparse
+import re
+from transformers import AutoProcessor, AutoModel
+from torchvision import transforms
+from data_loading import LMDBImageDataset
+from torch.utils.data import DataLoader
+from tqdm import tqdm
+import time
+
+torch.multiprocessing.set_sharing_strategy('file_system')
+
+def infer_image_size(model_name):
+    """
+    Infer image size from the model name.
+    Looks for a trailing hyphen followed by digits (e.g., "-336").
+    Defaults to 224 if not found.
+    """
+    match = re.search(r'-([0-9]+)$', model_name)
+    if match:
+        return int(match.group(1))
+    else:
+        return 224
+
+def collate_fn(batch):
+    images, labels = zip(*batch)
+    return list(images), list(labels)
+
+def main():
+    parser = argparse.ArgumentParser(description="Compute embeddings for a Hugging Face model")
+    parser.add_argument('--model_name', type=str, default="facebook/vit-mae-base",
+                        help="Hugging Face model name, e.g., facebook/vit-mae-base or openai/clip-vit-base-patch14-336")
+    parser.add_argument('--lmdb_path', type=str, default='../lmdb_all_crops_pmfeed_4_3_16', help="Path to the LMDB image dataset")
+    parser.add_argument('--batch_size', type=int, default=128)
+    parser.add_argument('--num_workers', type=int, default=8)
+    args = parser.parse_args()
+
+    # Infer image size from the model name
+    image_size = infer_image_size(args.model_name)
+    print(f"Inferred image size: {image_size}")
+
+    transform = transforms.Compose([
+        transforms.Resize((image_size, image_size)),
+    ])
+
+    # Create the dataset and dataloader.
+    dataset = LMDBImageDataset(
+        lmdb_path=args.lmdb_path, 
+        transform=transform, 
+        limit=None
+    )
+    dataloader = DataLoader(
+        dataset, 
+        batch_size=args.batch_size, 
+        shuffle=False, 
+        num_workers=args.num_workers,
+        collate_fn=collate_fn
+    )
+
+    # Load the model and processor.
+    model_name = args.model_name
+    processor = AutoProcessor.from_pretrained(model_name, do_normalize=False)
+    model = AutoModel.from_pretrained(model_name)
+    print(f"Using model: {model_name}")
+    
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device)
+    model.eval()
+
+    all_embeddings = []
+    all_cow_ids = []
+
+    # Loop through the dataset and compute embeddings.
+    with torch.no_grad():
+        for images, cow_ids in tqdm(dataloader, unit='batch'):
+            inputs = processor(images=images, return_tensors="pt")
+            inputs = inputs.to(device)
+            # Get the mean of the last hidden state as the image embedding.
+            if "clip-vit" in model_name:
+                image_features = model.get_image_features(**inputs)
+            elif "vit-mae" in model_name:
+                image_features = model(**inputs).last_hidden_state.mean(dim=1)
+            else:
+                image_features = model(**inputs).pooler_output
+            # image_features = model(**inputs).last_hidden_state.mean(dim=1) # mae model
+            # image_features = model.get_image_features(**inputs) # clip model
+            # image_features = model(**inputs).pooler_output # everything else
+            all_embeddings.append(image_features.cpu())
+            all_cow_ids.extend(cow_ids)
+
+    # Concatenate and save the embeddings.
+    embeddings = torch.cat(all_embeddings, dim=0)
+    output_file = f"{model_name.replace('/', '_')}_embeddings.pt"
+    torch.save(embeddings, output_file)
+    print(f"Embeddings saved to {output_file}")
+
+if __name__ == '__main__':
+    main()

identification_benchmark/classification/data_loading.py

@@ -0,0 +1,138 @@
+import torch
+from torch.utils.data import TensorDataset
+import tensorflow as tf
+import tensorflow_datasets as tfds
+import jax.numpy as jnp
+
+
+def get_datasets(
+        features_path='../big_model_inference/resnet18_embeddings.pt', 
+        labels_path='../big_model_inference/all_cow_ids.pt'
+    ):
+    embeddings_np = torch.load(features_path)
+    all_cow_ids =  torch.load(labels_path) - 1
+
+
+    # Set the seed for reproducibility
+    seed = 42
+    torch.manual_seed(seed)
+
+    # Assume embeddings_np and all_cow_ids are already loaded as PyTorch tensors
+    num_samples = len(embeddings_np)
+    indices = torch.randperm(num_samples)
+
+    # Calculate split indices for 70/20/10 split
+    train_end = int(0.001 * num_samples)
+    val_end = int(0.2 * num_samples)
+    train_indices = indices[:train_end]
+    val_indices = indices[train_end:val_end]
+    test_indices = indices[val_end:]
+
+    # print(train_indices[:10])
+    # print(val_indices[:10])
+    # print(test_indices[:10])
+
+#     assert torch.equal(train_indices[:10], torch.tensor([292622,  37548,  42432, 353497, 379054, 301165,  47066, 353666, 409458,
+#             454581]))
+#     assert torch.equal(val_indices[:10], torch.tensor([219340, 495317, 522025,  36026, 490924, 179563, 533196, 263518, 139048,
+#             72363]))
+#     assert torch.equal(test_indices[:10], torch.tensor([192226, 477583, 210506, 265639,  82907, 246325, 335726, 395405, 497690,
+#             388675]))
+    # Create datasets for each split
+    train_dataset = TensorDataset(embeddings_np[train_indices], all_cow_ids[train_indices])
+    val_dataset   = TensorDataset(embeddings_np[val_indices], all_cow_ids[val_indices])
+    test_dataset  = TensorDataset(embeddings_np[test_indices], all_cow_ids[test_indices])
+
+    print(f"Train set: {len(train_dataset)} samples")
+    print(f"Validation set: {len(val_dataset)} samples")
+    print(f"Test set: {len(test_dataset)} samples")
+    return train_dataset, val_dataset, test_dataset
+
+
+
+def get_time_series(
+        features_path='../big_model_inference/resnet18_embeddings.pt', 
+        labels_path='../big_model_inference/all_cow_ids.pt'
+    ):
+    embeddings_np = torch.load(features_path)
+    all_cow_ids =  torch.load(labels_path) - 1
+
+
+    num_samples = len(embeddings_np)
+
+    train_end = int(0.33 * num_samples)
+    val_end = int(0.66 * num_samples)
+
+    # Create datasets for each split
+    train_dataset = TensorDataset(embeddings_np[:train_end], all_cow_ids[:train_end])
+    val_dataset   = TensorDataset(embeddings_np[train_end:val_end], all_cow_ids[train_end:val_end])
+    test_dataset  = TensorDataset(embeddings_np[val_end:], all_cow_ids[val_end:])
+
+    print(f"Train set: {len(train_dataset)} samples")
+    print(f"Validation set: {len(val_dataset)} samples")
+    print(f"Test set: {len(test_dataset)} samples")
+    return train_dataset, val_dataset, test_dataset
+
+
+
+def get_time_series_tf(
+        features_path='../big_model_inference/resnet18_embeddings.pt', 
+        labels_path='../big_model_inference/all_cow_ids.pt'
+    ):
+    embeddings_np = torch.load(features_path)
+    all_cow_ids =  torch.load(labels_path) - 1
+    embeddings_np = embeddings_np.numpy()
+    all_cow_ids = all_cow_ids.numpy()
+
+    num_samples = len(embeddings_np)
+
+    train_end = int(0.33 * num_samples)
+    val_end = int(0.66 * num_samples)
+
+    # Create datasets for each split
+    train_dataset = tf.data.Dataset.from_tensor_slices((embeddings_np[:train_end], all_cow_ids[:train_end]))
+    val_dataset   = tf.data.Dataset.from_tensor_slices((embeddings_np[train_end:val_end], all_cow_ids[train_end:val_end]))
+    test_dataset  = tf.data.Dataset.from_tensor_slices((embeddings_np[val_end:], all_cow_ids[val_end:]))
+
+    print(f"Train set: {len(train_dataset)} samples")
+    print(f"Validation set: {len(val_dataset)} samples")
+    print(f"Test set: {len(test_dataset)} samples")
+    
+    batch_size = 32
+    
+    train_dataset = train_dataset.shuffle(len(train_dataset)).batch(
+        batch_size,
+        num_parallel_calls=tf.data.AUTOTUNE
+    ).prefetch(tf.data.AUTOTUNE)
+    
+    val_dataset = val_dataset.batch(
+        batch_size,
+        num_parallel_calls=tf.data.AUTOTUNE
+    ).prefetch(tf.data.AUTOTUNE)
+    
+    test_dataset = test_dataset.batch(
+        batch_size,
+        num_parallel_calls=tf.data.AUTOTUNE
+    ).prefetch(tf.data.AUTOTUNE)
+    
+    train_dataset = tfds.as_numpy(train_dataset)
+    val_dataset = tfds.as_numpy(val_dataset)
+    test_dataset = tfds.as_numpy(test_dataset)
+    return train_dataset, val_dataset, test_dataset, len(embeddings_np[0])
+
+if __name__ == "__main__":
+    train_dataset, val_dataset, test_dataset, in_features = get_time_series_tf(features_path='../big_model_inference/facebook_dinov2_base_embeddings.pt')
+    print(f"in features : {in_features}")
+    for batch in train_dataset:
+        batch = {
+            'feature' : jnp.array(batch[0]),
+            "label" : jnp.array(batch[1])
+        }
+        print(batch)
+        break
+    for batch in val_dataset:
+        print(batch)
+        break
+    for batch in test_dataset:
+        print(batch)
+        break

identification_benchmark/classification/knn_evaluation.py

@@ -0,0 +1,75 @@
+import faiss
+import numpy as np
+import torch
+import os, glob
+
+def get_results(features_path):
+    print(features_path)
+    embeddings_np = torch.load(features_path).numpy()
+    all_cow_ids =  torch.load("../big_model_inference/all_cow_ids.pt").numpy()
+
+
+    mid_point = len(embeddings_np) // 2
+    # print(f"mid_point : {mid_point}")
+    embeddings_np_first_half = embeddings_np[:mid_point]
+    embeddings_np_second_half = embeddings_np[mid_point:]
+
+    all_cow_ids_first_half = all_cow_ids[:mid_point]
+    all_cow_ids_second_half = all_cow_ids[mid_point:]
+
+    # # Assuming embeddings_np is your numpy array of shape (N, 512) and dtype=np.float32
+    d = embeddings_np_first_half.shape[1]  # Dimensionality (512)
+    nlist = 100  # Number of clusters (you can tune this parameter)
+
+
+    m = 8  # Number of subquantizers (must be a divisor of d)
+    nbits = 8  # Bits per subquantizer
+
+    flat_index = faiss.IndexFlatL2(d)
+    index_ivf = faiss.IndexIVFPQ(flat_index, d, nlist, m, nbits)
+    index_ivf.nprobe = 10
+    index_ivf.train(embeddings_np_first_half)
+    index_ivf.add(embeddings_np_first_half)
+    # flat_index.add(embeddings_np_first_half)
+    k = 6 
+    distances, indices = index_ivf.search(embeddings_np_second_half, k) 
+
+
+    # print("Nearest neighbors (indices) for the first 10 images:")
+    # print(indices[-10:])
+    # print("Corresponding distances:")
+    # print(distances[-10:])
+
+
+    # Calculate top-1 and top-5 accuracy
+    top1_correct = 0
+    top5_correct = 0
+
+    for i, indices_row in enumerate(indices):
+        query_id = all_cow_ids_second_half[i]
+        
+        # Get cow IDs for the retrieved results
+        retrieved_ids = [all_cow_ids_first_half[idx] for idx in indices_row]
+        
+        # Top-1: Check if the first result matches the query ID
+        if retrieved_ids[0] == query_id:
+            top1_correct += 1
+        
+        # Top-5: Check if any of the first 5 results match the query ID
+        if query_id in retrieved_ids[:5]:
+            top5_correct += 1
+
+    # Calculate accuracy rates
+    top1_accuracy = top1_correct / len(embeddings_np_second_half)
+    top5_accuracy = top5_correct / len(embeddings_np_second_half)
+
+    print(f"Top-1 Accuracy: {top1_accuracy:.4f}")
+    print(f"Top-5 Accuracy: {top5_accuracy:.4f}")
+    
+directory = '../big_model_inference'  # replace with your directory path
+pattern = os.path.join(directory, '*.pt')
+exclude_file = 'all_cow_ids.pt'
+for features_path in glob.glob(pattern):
+    if os.path.basename(features_path) != exclude_file:
+        get_results(features_path)
+        # print(features_path)

identification_benchmark/classification/model.py

@@ -0,0 +1,19 @@
+from flax import nnx  # The Flax NNX API.
+
+class LinearClassifier(nnx.Module):
+  def __init__(self, in_features, out_features, rngs: nnx.Rngs):
+    self.linear = nnx.Linear(in_features, out_features, rngs=rngs)
+
+  def __call__(self, x):
+    return self.linear(x)
+
+
+if __name__ == "__main__":
+    # Instantiate the model.
+    model = LinearClassifier(
+        in_features=512, 
+        out_features=8, 
+        rngs=nnx.Rngs(0)
+    )
+    # Visualize it.
+    nnx.display(model)

identification_benchmark/classification/train.py

@@ -0,0 +1,116 @@
+import glob
+import os
+# os.environ["JAX_PLATFORMS"] = "cpu"  # Must be set before importing jax
+from model import LinearClassifier
+from flax import nnx
+import optax
+from data_loading import get_time_series_tf
+import jax.numpy as jnp
+import numpy as np
+from copy import deepcopy
+
+
+def loss_fn(model: LinearClassifier, batch):
+    logits = model(batch['feature'])
+    loss = optax.softmax_cross_entropy_with_integer_labels(
+        logits=logits, labels=batch['label']
+    ).mean()
+    return loss, logits
+
+@nnx.jit
+def train_step(model: LinearClassifier, optimizer: nnx.Optimizer, batch):
+    """Train for a single step."""
+    grad_fn = nnx.value_and_grad(loss_fn, has_aux=True)
+    (loss, logits), grads = grad_fn(model, batch)
+    optimizer.update(grads)  # In-place updates.
+
+@nnx.jit
+def eval_step(model: LinearClassifier, metrics: nnx.MultiMetric, batch):
+    loss, logits = loss_fn(model, batch)
+    metrics.update(loss=loss, logits=logits, labels=batch['label'])  # In-place updates.
+
+
+
+def get_results(features_path):
+    print(features_path)
+
+    train_loader, val_loader, test_loader, in_features = get_time_series_tf(
+        features_path=features_path
+    )
+
+    model = LinearClassifier(
+        in_features=in_features, 
+        out_features=8, 
+        rngs=nnx.Rngs(0)
+    )
+    # nnx.display(model)
+
+    learning_rate = 0.005
+    optimizer = nnx.Optimizer(
+        model, 
+        optax.adamw(learning_rate=learning_rate)
+    )
+    # nnx.display(optimizer)
+
+    metrics = nnx.MultiMetric(
+        accuracy=nnx.metrics.Accuracy(),
+        loss=nnx.metrics.Average('loss'),
+    )
+
+    epochs = 100
+
+    best_accuracy = 0.0
+    best_model = deepcopy(model)
+    patience = 0
+    # train and validation goes here
+    for epoch in range(epochs):
+        if patience == 10:
+            break
+        for batch in train_loader:
+            batch = {
+                'feature' : jnp.array(batch[0]),
+                'label' : jnp.array(batch[1])
+            }
+            train_step(model, optimizer, batch)
+        for batch in val_loader:
+            batch = {
+                'feature' : jnp.array(batch[0]),
+                'label' : jnp.array(batch[1])
+            }
+            eval_step(model, metrics, batch)
+        # Log the test metrics.
+        results = metrics.compute()
+        
+        accuracy = results['accuracy'].item()
+        if accuracy > best_accuracy:
+            best_accuracy = accuracy
+            best_model = deepcopy(model)
+            patience = 0
+        else:
+            patience += 1
+        metrics.reset()  # Reset the metrics for the next training epoch.
+
+    print(f"best eval accuracy: {best_accuracy}")
+
+    # testing goes here
+    for batch in test_loader:
+        batch = {
+                'feature' : jnp.array(batch[0]),
+                'label' : jnp.array(batch[1])
+            }
+        eval_step(best_model, metrics, batch)
+    # Log the test metrics.
+        
+    results = metrics.compute()
+    accuracy = results['accuracy'].item()
+    print(f"test accuracy: {accuracy}")
+
+
+directory = '../big_model_inference'  # replace with your directory path
+pattern = os.path.join(directory, '*.pt')
+exclude_file = 'all_cow_ids.pt'
+for features_path in glob.glob(pattern):
+    if os.path.basename(features_path) != exclude_file:
+        get_results(features_path)
+        
+# get_results('../big_model_inference/facebook_dinov2_base_embeddings.pt')

identification_benchmark/construct_lmdb.py

@@ -0,0 +1,66 @@
+import os
+import lmdb
+import re
+import multiprocessing
+from tqdm import tqdm
+
+def sort_key(filename):
+    # Extract frame number and cow id from filenames like:
+    # "pmfeed_4_3_16_frame_10000_cow_1.jpg"
+    match = re.search(r'frame_(\d+)_cow_(\d+)', filename)
+    if match:
+        frame_number = int(match.group(1))
+        cow_id = int(match.group(2))
+        return (frame_number, cow_id)
+    return (float('inf'), float('inf'))
+
+def read_image(args):
+    image_folder, image_name = args
+    image_path = os.path.join(image_folder, image_name)
+    try:
+        with open(image_path, 'rb') as f:
+            image_data = f.read()
+        return (image_name, image_data)
+    except Exception as e:
+        print(f"Error reading {image_name}: {e}")
+        return None
+
+def main():
+    # Define your pathscon
+    image_folder = 'all_crops_pmfeed_4_3_16'
+    lmdb_path = 'lmdb_all_crops_pmfeed_4_3_16'
+    
+    # Create LMDB directory if it doesn't exist
+    if not os.path.exists(lmdb_path):
+        os.makedirs(lmdb_path)
+    
+    # List and sort JPEG files
+    image_files = [f for f in os.listdir(image_folder) if f.endswith('.jpg')]
+    sorted_files = sorted(image_files, key=sort_key)
+    
+    # For sanity check, take the first 20 images
+    sanity_files = sorted_files
+    
+    # Prepare arguments for multiprocessing
+    args = [(image_folder, image_name) for image_name in sanity_files]
+    
+    # Use multiprocessing Pool to read images concurrently
+    with multiprocessing.Pool(processes=multiprocessing.cpu_count()) as pool:
+        results = list(tqdm(pool.imap(read_image, args), total=len(args), desc="Reading images"))
+    
+    # Filter out any failed reads
+    results = [res for res in results if res is not None]
+    
+    # Open LMDB environment with an appropriate map size (e.g., 10GB)
+    map_size = 10 * 1024 * 1024 * 1024  # 10GB in bytes
+    env = lmdb.open(lmdb_path, map_size=map_size)
+    
+    # Write the results into LMDB using a single write transaction
+    with env.begin(write=True) as txn:
+        for key, value in tqdm(results, desc="Writing to LMDB"):
+            txn.put(key.encode('utf-8'), value)
+    
+    print("LMDB database creation complete for all images!")
+
+if __name__ == '__main__':
+    main()

identification_benchmark/crop_pmfeed_4_3_16.py

@@ -0,0 +1,90 @@
+import cv2
+import pandas as pd
+import pickle
+import os
+
+# Files
+pickle_filename = "../pmfeed_4_3_16_bboxes_and_labels.pkl"
+video_filename = "../pmfeed_4_3_16.mp4"
+output_dir = "all_crops_pmfeed_4_3_16"
+
+# Create output directory if it doesn't exist
+os.makedirs(output_dir, exist_ok=True)
+
+# Load the bounding boxes DataFrame from the pickle file
+with open(pickle_filename, "rb") as f:
+    df = pickle.load(f)
+
+# Open the video file
+cap = cv2.VideoCapture(video_filename)
+if not cap.isOpened():
+    raise IOError(f"Cannot open video file {video_filename}")
+
+# Get video dimensions
+frame_width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+frame_height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+print(f"Video dimensions: {frame_width}x{frame_height}")
+
+# Initialize sliding window pointers and frame counter
+num_rows = len(df)
+i = 0
+frames_processed = 0
+# max_frames = 3  # only process first 3 frames
+
+while i < num_rows:
+    # Get the current frame_id for this sliding window
+    current_frame_id = int(df.iloc[i]["frame_id"])
+    j = i
+    # Move j until the frame_id changes
+    while j < num_rows and df.iloc[j]["frame_id"] == current_frame_id:
+        j += 1
+
+    # Set the video to the appropriate frame (frame_id is assumed to be 1-indexed)
+    cap.set(cv2.CAP_PROP_POS_FRAMES, current_frame_id - 1)
+    ret, frame = cap.read()
+    if not ret:
+        print(f"Warning: Could not read frame {current_frame_id}")
+        i = j
+        continue
+
+    # Process all bounding boxes for this frame (from row i to j-1)
+    for index in range(i, j):
+        row = df.iloc[index]
+        # Assuming coordinates are normalized: (center x, center y, width, height)
+        x_center = row["x"]
+        y_center = row["y"]
+        bbox_width = row["w"]
+        bbox_height = row["h"]
+
+        # Convert normalized coordinates to absolute pixel values
+        left = int((x_center - bbox_width / 2) * frame_width)
+        top = int((y_center - bbox_height / 2) * frame_height)
+        right = int((x_center + bbox_width / 2) * frame_width)
+        bottom = int((y_center + bbox_height / 2) * frame_height)
+
+        # Clamp the coordinates to within the frame dimensions
+        left = max(left, 0)
+        top = max(top, 0)
+        right = min(right, frame_width)
+        bottom = min(bottom, frame_height)
+
+        # Skip if resulting crop dimensions are invalid
+        if right - left <= 0 or bottom - top <= 0:
+            print(f"Warning: Invalid crop dimensions for frame {current_frame_id}, tracklet {row['tracklet_id']}")
+            continue
+
+        # Crop the image
+        crop_img = frame[top:bottom, left:right]
+
+        # Save crop image with filename format: "pmfeed_4_3_16_frame_<frame_id>_cow_<tracklet_id>.jpg"
+        filename = f"pmfeed_4_3_16_frame_{current_frame_id}_cow_{int(row['tracklet_id'])}.jpg"
+        output_path = os.path.join(output_dir, filename)
+        cv2.imwrite(output_path, crop_img)
+        print(f"Saved crop: {output_path}")
+
+    frames_processed += 1
+    i = j
+
+# Release video capture
+cap.release()
+print("Cropping all frames completed.")

requirement.txt

@@ -0,0 +1,201 @@
+# packages in environment at /user/work/xf16910/.conda/envs/py310:
+#
+# Name                    Version                   Build  Channel
+_libgcc_mutex             0.1                 conda_forge    conda-forge
+_openmp_mutex             4.5                       2_gnu    conda-forge
+absl-py                   2.2.1                    pypi_0    pypi
+accelerate                1.5.2                    pypi_0    pypi
+aiohappyeyeballs          2.6.1                    pypi_0    pypi
+aiohttp                   3.11.15                  pypi_0    pypi
+aiosignal                 1.3.2                    pypi_0    pypi
+albucore                  0.0.23                   pypi_0    pypi
+albumentations            2.0.5                    pypi_0    pypi
+annotated-types           0.7.0                    pypi_0    pypi
+array-record              0.7.1                    pypi_0    pypi
+astunparse                1.6.3                    pypi_0    pypi
+async-timeout             5.0.1                    pypi_0    pypi
+attrs                     25.3.0                   pypi_0    pypi
+bzip2                     1.0.8                h4bc722e_7    conda-forge
+c-ares                    1.34.5               hb9d3cd8_0    conda-forge
+ca-certificates           2025.1.31            hbcca054_0    conda-forge
+certifi                   2025.1.31                pypi_0    pypi
+charset-normalizer        3.4.1                    pypi_0    pypi
+chex                      0.1.89                   pypi_0    pypi
+contourpy                 1.3.1                    pypi_0    pypi
+curl                      7.88.1               hdc1c0ab_1    conda-forge
+cycler                    0.12.1                   pypi_0    pypi
+datasets                  3.5.0                    pypi_0    pypi
+dill                      0.3.8                    pypi_0    pypi
+dm-tree                   0.1.9                    pypi_0    pypi
+docstring-parser          0.16                     pypi_0    pypi
+einops                    0.8.1                    pypi_0    pypi
+etils                     1.12.2                   pypi_0    pypi
+expat                     2.7.0                h5888daf_0    conda-forge
+faiss-gpu                 1.7.2                    pypi_0    pypi
+filelock                  3.18.0                   pypi_0    pypi
+flatbuffers               25.2.10                  pypi_0    pypi
+flax                      0.10.4                   pypi_0    pypi
+fonttools                 4.56.0                   pypi_0    pypi
+frozenlist                1.5.0                    pypi_0    pypi
+fsspec                    2024.12.0                pypi_0    pypi
+gast                      0.6.0                    pypi_0    pypi
+gettext                   0.23.1               h5888daf_0    conda-forge
+gettext-tools             0.23.1               h5888daf_0    conda-forge
+git                       2.45.2          pl5340h9abc3c3_1    anaconda
+git-lfs                   1.6                      pypi_0    pypi
+google-pasta              0.2.0                    pypi_0    pypi
+grpcio                    1.71.0                   pypi_0    pypi
+h5py                      3.13.0                   pypi_0    pypi
+huggingface-hub           0.29.3                   pypi_0    pypi
+humanize                  4.12.2                   pypi_0    pypi
+idna                      3.10                     pypi_0    pypi
+immutabledict             4.2.1                    pypi_0    pypi
+importlib-resources       6.5.2                    pypi_0    pypi
+jax                       0.5.3                    pypi_0    pypi
+jax-cuda12-pjrt           0.5.3                    pypi_0    pypi
+jax-cuda12-plugin         0.5.3                    pypi_0    pypi
+jaxlib                    0.5.3                    pypi_0    pypi
+jinja2                    3.1.6                    pypi_0    pypi
+joblib                    1.4.2                    pypi_0    pypi
+keras                     3.9.1                    pypi_0    pypi
+keyutils                  1.6.1                h166bdaf_0    conda-forge
+kiwisolver                1.4.8                    pypi_0    pypi
+krb5                      1.20.1               h81ceb04_0    conda-forge
+ld_impl_linux-64          2.43                 h712a8e2_4    conda-forge
+libasprintf               0.23.1               h8e693c7_0    conda-forge
+libasprintf-devel         0.23.1               h8e693c7_0    conda-forge
+libclang                  18.1.1                   pypi_0    pypi
+libcurl                   7.88.1               hdc1c0ab_1    conda-forge
+libedit                   3.1.20250104    pl5321h7949ede_0    conda-forge
+libev                     4.33                 hd590300_2    conda-forge
+libexpat                  2.7.0                h5888daf_0    conda-forge
+libffi                    3.4.6                h2dba641_0    conda-forge
+libgcc                    14.2.0               h767d61c_2    conda-forge
+libgcc-ng                 14.2.0               h69a702a_2    conda-forge
+libgettextpo              0.23.1               h5888daf_0    conda-forge
+libgettextpo-devel        0.23.1               h5888daf_0    conda-forge
+libgomp                   14.2.0               h767d61c_2    conda-forge
+liblzma                   5.6.4                hb9d3cd8_0    conda-forge
+liblzma-devel             5.6.4                hb9d3cd8_0    conda-forge
+libnghttp2                1.58.0               h47da74e_1    conda-forge
+libnsl                    2.0.1                hd590300_0    conda-forge
+libsqlite                 3.46.0               hde9e2c9_0    conda-forge
+libssh2                   1.11.0               h0841786_0    conda-forge
+libstdcxx                 14.2.0               h8f9b012_2    conda-forge
+libstdcxx-ng              14.2.0               h4852527_2    conda-forge
+libuuid                   2.38.1               h0b41bf4_0    conda-forge
+libxcrypt                 4.4.36               hd590300_1    conda-forge
+libzlib                   1.2.13               h4ab18f5_6    conda-forge
+lightning-utilities       0.14.2                   pypi_0    pypi
+lmdb                      1.6.2                    pypi_0    pypi
+markdown                  3.7                      pypi_0    pypi
+markdown-it-py            3.0.0                    pypi_0    pypi
+markupsafe                3.0.2                    pypi_0    pypi
+matplotlib                3.10.1                   pypi_0    pypi
+mdurl                     0.1.2                    pypi_0    pypi
+ml-dtypes                 0.5.1                    pypi_0    pypi
+mpmath                    1.3.0                    pypi_0    pypi
+msgpack                   1.1.0                    pypi_0    pypi
+multidict                 6.3.0                    pypi_0    pypi
+multiprocess              0.70.16                  pypi_0    pypi
+namex                     0.0.8                    pypi_0    pypi
+ncurses                   6.5                  h2d0b736_3    conda-forge
+nest-asyncio              1.6.0                    pypi_0    pypi
+networkx                  3.4.2                    pypi_0    pypi
+numpy                     1.26.4                   pypi_0    pypi
+nvidia-cublas-cu12        12.4.5.8                 pypi_0    pypi
+nvidia-cuda-cupti-cu12    12.4.127                 pypi_0    pypi
+nvidia-cuda-nvcc-cu12     12.8.93                  pypi_0    pypi
+nvidia-cuda-nvrtc-cu12    12.4.127                 pypi_0    pypi
+nvidia-cuda-runtime-cu12  12.4.127                 pypi_0    pypi
+nvidia-cudnn-cu12         9.1.0.70                 pypi_0    pypi
+nvidia-cufft-cu12         11.2.1.3                 pypi_0    pypi
+nvidia-curand-cu12        10.3.5.147               pypi_0    pypi
+nvidia-cusolver-cu12      11.6.1.9                 pypi_0    pypi
+nvidia-cusparse-cu12      12.3.1.170               pypi_0    pypi
+nvidia-cusparselt-cu12    0.6.2                    pypi_0    pypi
+nvidia-nccl-cu12          2.21.5                   pypi_0    pypi
+nvidia-nvjitlink-cu12     12.4.127                 pypi_0    pypi
+nvidia-nvtx-cu12          12.4.127                 pypi_0    pypi
+opencv-python             4.11.0.86                pypi_0    pypi
+opencv-python-headless    4.11.0.86                pypi_0    pypi
+openssl                   3.5.0                h7b32b05_0    conda-forge
+opt-einsum                3.4.0                    pypi_0    pypi
+optax                     0.2.4                    pypi_0    pypi
+optree                    0.14.1                   pypi_0    pypi
+orbax-checkpoint          0.11.10                  pypi_0    pypi
+packaging                 24.2                     pypi_0    pypi
+pandas                    2.2.3                    pypi_0    pypi
+pcre2                     10.42                hcad00b1_0    conda-forge
+perl                      5.32.1          7_hd590300_perl5    conda-forge
+pillow                    11.1.0                   pypi_0    pypi
+pip                       25.0.1             pyh8b19718_0    conda-forge
+promise                   2.3                      pypi_0    pypi
+propcache                 0.3.1                    pypi_0    pypi
+protobuf                  3.20.3                   pypi_0    pypi
+psutil                    7.0.0                    pypi_0    pypi
+py-cpuinfo                9.0.0                    pypi_0    pypi
+pyarrow                   19.0.1                   pypi_0    pypi
+pycocotools               2.0.8                    pypi_0    pypi
+pydantic                  2.11.1                   pypi_0    pypi
+pydantic-core             2.33.0                   pypi_0    pypi
+pygments                  2.19.1                   pypi_0    pypi
+pyparsing                 3.2.3                    pypi_0    pypi
+python                    3.10.14         hd12c33a_0_cpython    conda-forge
+python-dateutil           2.9.0.post0              pypi_0    pypi
+pytz                      2025.2                   pypi_0    pypi
+pyyaml                    6.0.2                    pypi_0    pypi
+readline                  8.2                  h8c095d6_2    conda-forge
+regex                     2024.11.6                pypi_0    pypi
+requests                  2.32.3                   pypi_0    pypi
+rich                      13.9.4                   pypi_0    pypi
+safetensors               0.5.3                    pypi_0    pypi
+scikit-learn              1.6.1                    pypi_0    pypi
+scipy                     1.15.2                   pypi_0    pypi
+seaborn                   0.13.2                   pypi_0    pypi
+setuptools                75.8.2             pyhff2d567_0    conda-forge
+simple-parsing            0.1.7                    pypi_0    pypi
+simplejson                3.20.1                   pypi_0    pypi
+simsimd                   6.2.1                    pypi_0    pypi
+six                       1.17.0                   pypi_0    pypi
+stringzilla               3.12.3                   pypi_0    pypi
+sympy                     1.13.1                   pypi_0    pypi
+tensorboard               2.19.0                   pypi_0    pypi
+tensorboard-data-server   0.7.2                    pypi_0    pypi
+tensorflow                2.19.0                   pypi_0    pypi
+tensorflow-datasets       4.9.8                    pypi_0    pypi
+tensorflow-io-gcs-filesystem 0.37.1                   pypi_0    pypi
+tensorflow-metadata       1.16.1                   pypi_0    pypi
+tensorstore               0.1.73                   pypi_0    pypi
+termcolor                 2.5.0                    pypi_0    pypi
+tf-keras                  2.19.0                   pypi_0    pypi
+threadpoolctl             3.6.0                    pypi_0    pypi
+timm                      1.0.15                   pypi_0    pypi
+tk                        8.6.14               h39e8969_0    anaconda
+tokenizers                0.21.1                   pypi_0    pypi
+toml                      0.10.2                   pypi_0    pypi
+toolz                     1.0.0                    pypi_0    pypi
+torch                     2.6.0                    pypi_0    pypi
+torchmetrics              1.7.0                    pypi_0    pypi
+torchvision               0.21.0                   pypi_0    pypi
+tqdm                      4.67.1                   pypi_0    pypi
+transformers              4.50.3                   pypi_0    pypi
+treescope                 0.1.9                    pypi_0    pypi
+triton                    3.2.0                    pypi_0    pypi
+typing-extensions         4.13.0                   pypi_0    pypi
+typing-inspection         0.4.0                    pypi_0    pypi
+tzdata                    2025.2                   pypi_0    pypi
+ultralytics               8.3.99                   pypi_0    pypi
+ultralytics-thop          2.0.14                   pypi_0    pypi
+urllib3                   2.3.0                    pypi_0    pypi
+werkzeug                  3.1.3                    pypi_0    pypi
+wheel                     0.45.1             pyhd8ed1ab_1    conda-forge
+wrapt                     1.17.2                   pypi_0    pypi
+xxhash                    3.5.0                    pypi_0    pypi
+xz                        5.6.4                hbcc6ac9_0    conda-forge
+xz-gpl-tools              5.6.4                hbcc6ac9_0    conda-forge
+xz-tools                  5.6.4                hb9d3cd8_0    conda-forge
+yarl                      1.18.3                   pypi_0    pypi
+zipp                      3.21.0                   pypi_0    pypi
+zlib                      1.2.13               h4ab18f5_6    conda-forge
+zstd                      1.5.6                ha6fb4c9_0    conda-forge