File size: 7,783 Bytes
890fcc7 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 | 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)
|