from collections import OrderedDict from pathlib import Path import os import pickle import cv2 import numpy as np class EmbeddingComputer: def __init__(self, dataset, test_dataset, grid_off, max_batch=1024): self.model = None self.dataset = dataset self.test_dataset = test_dataset self.crop_size = (128, 384) os.makedirs("./cache/embeddings/", exist_ok=True) self.cache_path = "./cache/embeddings/{}_embedding.pkl" self.cache = {} self.cache_name = "" self.grid_off = grid_off self.max_batch = max_batch # Only used for the general ReID model (not FastReID) self.normalize = False def load_cache(self, path): self.cache_name = path cache_path = self.cache_path.format(path) if os.path.exists(cache_path): with open(cache_path, "rb") as fp: self.cache = pickle.load(fp) def get_horizontal_split_patches(self, image, bbox, tag, idx, viz=False): if isinstance(image, np.ndarray): h, w = image.shape[:2] else: h, w = image.shape[2:] bbox = np.array(bbox) bbox = bbox.astype(np.int) if bbox[0] < 0 or bbox[1] < 0 or bbox[2] > w or bbox[3] > h: # Faulty Patch Correction bbox[0] = np.clip(bbox[0], 0, None) bbox[1] = np.clip(bbox[1], 0, None) bbox[2] = np.clip(bbox[2], 0, image.shape[1]) bbox[3] = np.clip(bbox[3], 0, image.shape[0]) x1, y1, x2, y2 = bbox w = x2 - x1 h = y2 - y1 ### TODO - Write a generalized split logic split_boxes = [ [x1, y1, x1 + w, y1 + h / 3], [x1, y1 + h / 3, x1 + w, y1 + (2 / 3) * h], [x1, y1 + (2 / 3) * h, x1 + w, y1 + h], ] split_boxes = np.array(split_boxes, dtype="int") patches = [] # breakpoint() for ix, patch_coords in enumerate(split_boxes): if isinstance(image, np.ndarray): im1 = image[patch_coords[1] : patch_coords[3], patch_coords[0] : patch_coords[2], :] if viz: ## TODO - change it from torch tensor to numpy array dirs = "./viz/{}/{}".format(tag.split(":")[0], tag.split(":")[1]) Path(dirs).mkdir(parents=True, exist_ok=True) cv2.imwrite( os.path.join(dirs, "{}_{}.png".format(idx, ix)), im1.squeeze(0).permute(1, 2, 0).detach().cpu().numpy() * 255, ) patch = cv2.cvtColor(im1, cv2.COLOR_BGR2RGB) patch = cv2.resize(patch, self.crop_size, interpolation=cv2.INTER_LINEAR) patch = torch.as_tensor(patch.astype("float32").transpose(2, 0, 1)) patch = patch.unsqueeze(0) # print("test ", patch.shape) patches.append(patch) else: im1 = image[:, :, patch_coords[1] : patch_coords[3], patch_coords[0] : patch_coords[2]] patch = torchvision.transforms.functional.resize(im1, (256, 128)) patches.append(patch) patches = torch.cat(patches, dim=0) # print("Patches shape ", patches.shape) # patches = np.array(patches) # print("ALL SPLIT PATCHES SHAPE - ", patches.shape) return patches def compute_embedding(self, img, bbox, tag): if self.cache_name != tag.split(":")[0]: self.load_cache(tag.split(":")[0]) if tag in self.cache: embs = self.cache[tag] if embs.shape[0] != bbox.shape[0]: raise RuntimeError( "ERROR: The number of cached embeddings don't match the " "number of detections.\nWas the detector model changed? Delete cache if so." ) return embs if self.model is None: self.initialize_model() # Generate all of the patches crops = [] if self.grid_off: # Basic embeddings h, w = img.shape[:2] results = np.round(bbox).astype(np.int32) results[:, 0] = results[:, 0].clip(0, w) results[:, 1] = results[:, 1].clip(0, h) results[:, 2] = results[:, 2].clip(0, w) results[:, 3] = results[:, 3].clip(0, h) crops = [] for p in results: crop = img[p[1] : p[3], p[0] : p[2]] crop = cv2.cvtColor(crop, cv2.COLOR_BGR2RGB) crop = cv2.resize(crop, self.crop_size, interpolation=cv2.INTER_LINEAR).astype(np.float32) if self.normalize: crop /= 255 crop -= np.array((0.485, 0.456, 0.406)) crop /= np.array((0.229, 0.224, 0.225)) crop = torch.as_tensor(crop.transpose(2, 0, 1)) crop = crop.unsqueeze(0) crops.append(crop) else: # Grid patch embeddings for idx, box in enumerate(bbox): crop = self.get_horizontal_split_patches(img, box, tag, idx) crops.append(crop) crops = torch.cat(crops, dim=0) # Create embeddings and l2 normalize them embs = [] for idx in range(0, len(crops), self.max_batch): batch_crops = crops[idx : idx + self.max_batch] batch_crops = batch_crops.cuda() with torch.no_grad(): batch_embs = self.model(batch_crops) embs.extend(batch_embs) embs = torch.stack(embs) embs = torch.nn.functional.normalize(embs, dim=-1) if not self.grid_off: embs = embs.reshape(bbox.shape[0], -1, embs.shape[-1]) embs = embs.cpu().numpy() self.cache[tag] = embs return embs def initialize_model(self): if self.dataset == "mot17": if self.test_dataset: path = "external/weights/mot17_sbs_S50.pth" else: return self._get_general_model() elif self.dataset == "mot20": if self.test_dataset: path = "external/weights/mot20_sbs_S50.pth" else: return self._get_general_model() elif self.dataset == "dance": path = "external/weights/dance_sbs_S50.pth" else: raise RuntimeError("Need the path for a new ReID model.") model = FastReID(path) model.eval() model.cuda() model.half() self.model = model def _get_general_model(self): """Used for the half-val for MOT17/20. The MOT17/20 SBS models are trained over the half-val we evaluate on as well. Instead we use a different model for validation. """ model = torchreid.models.build_model(name="osnet_ain_x1_0", num_classes=2510, loss="softmax", pretrained=False) sd = torch.load("external/weights/osnet_ain_ms_d_c.pth.tar")["state_dict"] new_state_dict = OrderedDict() for k, v in sd.items(): name = k[7:] # remove `module.` new_state_dict[name] = v # load params model.load_state_dict(new_state_dict) model.eval() model.cuda() self.model = model self.crop_size = (128, 256) self.normalize = True def dump_cache(self): if self.cache_name: with open(self.cache_path.format(self.cache_name), "wb") as fp: pickle.dump(self.cache, fp)