Upload 6 files

analyze.py

@@ -0,0 +1,31 @@
+from CircumSpect.dense import describe_image
+from CircumSpect.faces import recognize_users
+import cv2
+import time
+
+def analyze_image(cap):
+    users, recognized = recognize_users(cap)
+
+    captions, annotated = describe_image(recognized)
+
+    if users == []:
+        users = "No faces identified"
+
+    if type(users) == list:
+        users = ", ".join(users)
+
+    output = f"""Faces: {users}
+View description: {", ".join(captions)}"""
+    return output, annotated
+
+# cap = cv2.VideoCapture(0)
+# while True:
+#     output, image = analyze_image(cap)
+#     print(output)
+
+#     cv2.imshow("Annotated Image", image)
+#     if cv2.waitKey(1) & 0xFF == ord('q'):
+#         break
+
+# cap.release()
+# cv2.destroyAllWindows()

dataset.py

@@ -0,0 +1,115 @@
+import os
+import pickle
+
+import h5py
+import torch
+from torch.utils.data import Dataset
+import torchvision.transforms as transforms
+from PIL import Image
+
+
+class DenseCapDataset(Dataset):
+
+    @staticmethod
+    def collate_fn(batch):
+        """Use in torch.utils.data.DataLoader
+        """
+
+        return tuple(zip(*batch)) # as tuples instead of stacked tensors
+
+    @staticmethod
+    def get_transform():
+        """More complicated transform utils in torchvison/references/detection/transforms.py
+        """
+
+        transform = transforms.Compose([
+            transforms.ToTensor(),
+            transforms.Normalize((0.485, 0.456, 0.406), (0.229, 0.224, 0.225)),
+        ])
+
+        return transform
+
+    def __init__(self, img_dir_root, vg_data_path, look_up_tables_path, dataset_type=None, transform=None):
+
+        assert dataset_type in {None, 'train', 'test', 'val'}
+
+        super(DenseCapDataset, self).__init__()
+
+        self.img_dir_root = img_dir_root
+        self.vg_data_path = vg_data_path
+        self.look_up_tables_path = look_up_tables_path
+        self.dataset_type = dataset_type  # if dataset_type is None, all data will be use
+        self.transform = transform
+
+        # === load data here ====
+
+        self.vg_data = h5py.File(vg_data_path, 'r')
+        self.look_up_tables = pickle.load(open(look_up_tables_path, 'rb'))
+
+    def set_dataset_type(self, dataset_type, verbose=True):
+
+        assert dataset_type in {None, 'train', 'test', 'val'}
+
+        if verbose:
+            print('[DenseCapDataset]: {} switch to {}'.format(self.dataset_type, dataset_type))
+
+        self.dataset_type = dataset_type
+
+    def __getitem__(self, idx):
+
+        vg_idx = self.look_up_tables['split'][self.dataset_type][idx] if self.dataset_type else idx
+
+        img_path = os.path.join(self.img_dir_root, self.look_up_tables['idx_to_directory'][vg_idx],
+                                self.look_up_tables['idx_to_filename'][vg_idx])
+
+        img = Image.open(img_path).convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+        else:
+            img = transforms.ToTensor()(img)
+
+        first_box_idx = self.vg_data['img_to_first_box'][vg_idx]
+        last_box_idx = self.vg_data['img_to_last_box'][vg_idx]
+
+        boxes = torch.as_tensor(self.vg_data['boxes'][first_box_idx: last_box_idx+1], dtype=torch.float32)
+        caps = torch.as_tensor(self.vg_data['captions'][first_box_idx: last_box_idx+1], dtype=torch.long)
+        caps_len = torch.as_tensor(self.vg_data['lengths'][first_box_idx: last_box_idx+1], dtype=torch.long)
+
+        targets = {
+            'boxes': boxes,
+            'caps': caps,
+            'caps_len': caps_len,
+        }
+
+        info = {
+            'idx': vg_idx,
+            'dir': self.look_up_tables['idx_to_directory'][vg_idx],
+            'file_name': self.look_up_tables['idx_to_filename'][vg_idx]
+        }
+
+        return img, targets, info
+
+    def __len__(self):
+
+        if self.dataset_type:
+            return len(self.look_up_tables['split'][self.dataset_type])
+        else:
+            return len(self.look_up_tables['filename_to_idx'])
+
+if __name__ == '__main__':
+
+    IMG_DIR_ROOT = './data/visual-genome'
+    VG_DATA_PATH = './data/VG-regions.h5'
+    LOOK_UP_TABLES_PATH = './data/VG-regions-dicts.pkl'
+
+    dcd = DenseCapDataset(IMG_DIR_ROOT, VG_DATA_PATH, LOOK_UP_TABLES_PATH)
+
+    print('all', len(dcd))
+    print(dcd[0])
+
+    for data_type in {'train', 'test', 'val'}:
+
+        dcd.set_dataset_type(data_type)
+
+        print(data_type, len(dcd))
+        print(dcd[0])

dense.py

@@ -0,0 +1,85 @@
+from matplotlib.patches import Rectangle
+from CircumSpect.describe import process_image
+import matplotlib.pyplot as plt
+from PIL import Image
+import ocrmac
+import json
+import time
+import cv2
+import os
+
+time.sleep(2)
+
+with open('pwd.txt', 'r') as pwd:
+    folder_location = pwd.read()
+
+
+def crop_and_save_image(img, box, output_path):
+
+    # Convert box coordinates to integers
+    box = [int(coord) for coord in box]
+
+    # Crop the image to the specified region of interest
+    cropped_img = img[box[1]:box[3], box[0]:box[2]]
+    cv2.imwrite(output_path, cropped_img)
+
+
+def visualize_result(image_file_path, result):
+    assert isinstance(result, list)
+
+    og_img = cv2.imread(image_file_path)
+    img = cv2.imread(image_file_path)
+
+    captions = []
+
+    for r in result:
+        box = r['box']
+        caption = r['cap']
+        if "<unk>" in caption:
+            crop_and_save_image(og_img, box, "ocr.png")
+            recognized = ocrmac.OCR('Sample Images/Image.jpeg').recognize()
+            caption = caption.replace("<unk>", recognized[0][0])
+        cv2.rectangle(img, (int(box[0]), int(box[1])),
+                      (int(box[2]), int(box[3])), (0, 0, 255), 2)
+        cv2.rectangle(img, (int(box[0]), int(box[1])), (int(
+            box[2]), int(box[1])-50), (200, 200, 200), -1)
+        cv2.rectangle(img, (int(box[0]), int(box[1])),
+                      (int(box[2]), int(box[1])-50), (0, 0, 0), 2)
+        cv2.putText(img, caption, (int(box[0]), int(
+            box[1]) - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 0, 0), 2)
+        captions.append(caption)
+
+    cv2.imwrite("output.png", img)
+
+    return captions, img
+
+
+def describe_image(frame):
+    IMG_FILE_PATH = f'{folder_location}image.png'
+
+    cv2.imwrite(IMG_FILE_PATH, frame)
+    process_image(IMG_FILE_PATH, folder_location)
+
+    RESULT_JSON_PATH = f'{folder_location}CircumSpect/result.json'
+    with open(RESULT_JSON_PATH, 'r') as f:
+        results = json.load(f)
+
+    TO_K = 10
+    assert IMG_FILE_PATH in results.keys()
+    captions, frame = visualize_result(
+        IMG_FILE_PATH, results[IMG_FILE_PATH][:TO_K])
+
+    return captions, frame
+
+if __name__ == "__main__":
+    cap = cv2.VideoCapture(0)
+    time.sleep(2)
+    start = time.time()
+    while True:
+        end = time.time()
+        print(end-start)
+        _, img = cap.read()
+        caption, frame = describe_image(img)
+        cv2.imshow("CircumSpect", frame)
+        cv2.waitKey(1)
+        start = time.time()

describe.py

@@ -0,0 +1,239 @@
+import os
+import h5py
+import json
+import pickle
+import argparse
+
+import torch
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+import torchvision.transforms as transforms
+
+from CircumSpect.model.densecap import densecap_resnet50_fpn
+
+model = None
+first_run = True
+
+def load_model(console_args):
+
+    with open(console_args.config_json, 'r') as f:
+        model_args = json.load(f)
+
+    model = densecap_resnet50_fpn(backbone_pretrained=model_args['backbone_pretrained'],
+                                  return_features=console_args.extract,
+                                  feat_size=model_args['feat_size'],
+                                  hidden_size=model_args['hidden_size'],
+                                  max_len=model_args['max_len'],
+                                  emb_size=model_args['emb_size'],
+                                  rnn_num_layers=model_args['rnn_num_layers'],
+                                  vocab_size=model_args['vocab_size'],
+                                  fusion_type=model_args['fusion_type'],
+                                  box_detections_per_img=console_args.box_per_img)
+
+    checkpoint = torch.load(console_args.model_checkpoint, map_location=torch.device('cpu'))
+    model.load_state_dict(checkpoint['model'])
+
+    if console_args.verbose and 'results_on_val' in checkpoint.keys():
+        print('[INFO]: checkpoint {} loaded'.format(console_args.model_checkpoint))
+        print('[INFO]: correspond performance on val set:')
+        for k, v in checkpoint['results_on_val'].items():
+            if not isinstance(v, dict):
+                print('        {}: {:.3f}'.format(k, v))
+
+    return model
+
+
+def get_image_path(console_args):
+
+    img_list = []
+
+    if os.path.isdir(console_args.img_path):
+        for file_name in os.listdir(console_args.img_path):
+            img_list.append(os.path.join(console_args.img_path, file_name))
+    else:
+        img_list.append(console_args.img_path)
+
+    return img_list
+
+
+def img_to_tensor(img_list):
+
+    assert isinstance(img_list, list) and len(img_list) > 0
+
+    img_tensors = []
+
+    for img_path in img_list:
+
+        img = Image.open(img_path).convert("RGB")
+
+        img_tensors.append(transforms.ToTensor()(img))
+
+    return img_tensors
+
+
+def describe_images(model, img_list, device, console_args):
+
+    assert isinstance(img_list, list)
+    assert isinstance(console_args.batch_size, int) and console_args.batch_size > 0
+
+    all_results = []
+
+    with torch.no_grad():
+
+        model.to(device)
+        model.eval()
+
+        for i in tqdm(range(0, len(img_list), console_args.batch_size), disable=not console_args.verbose):
+
+            image_tensors = img_to_tensor(img_list[i:i+console_args.batch_size])
+            input_ = [t.to(device) for t in image_tensors]
+
+            results = model(input_)
+
+            all_results.extend([{k:v.cpu() for k,v in r.items()} for r in results])
+
+    return all_results
+
+
+def save_results_to_file(img_list, all_results, console_args):
+
+    with open(os.path.join(console_args.lut_path), 'rb') as f:
+        look_up_tables = pickle.load(f)
+
+    idx_to_token = look_up_tables['idx_to_token']
+
+    results_dict = {}
+    if console_args.extract:
+        total_box = sum(len(r['boxes']) for r in all_results)
+        start_idx = 0
+        img_idx = 0
+        h = h5py.File(os.path.join(console_args.result_dir, 'box_feats.h5'), 'w')
+        h.create_dataset('feats', (total_box, all_results[0]['feats'].shape[1]), dtype=np.float32)
+        h.create_dataset('boxes', (total_box, 4), dtype=np.float32)
+        h.create_dataset('start_idx', (len(img_list),), dtype=np.long)
+        h.create_dataset('end_idx', (len(img_list),), dtype=np.long)
+
+    for img_path, results in zip(img_list, all_results):
+
+        if console_args.verbose:
+            print('[Result] ==== {} ====='.format(img_path))
+
+        results_dict[img_path] = []
+        for box, cap, score in zip(results['boxes'], results['caps'], results['scores']):
+
+            r = {
+                'box': [round(c, 2) for c in box.tolist()],
+                'score': round(score.item(), 2),
+                'cap': ' '.join(idx_to_token[idx] for idx in cap.tolist()
+                                if idx_to_token[idx] not in ['<pad>', '<bos>', '<eos>'])
+            }
+
+            if console_args.verbose and r['score'] > 0.9:
+                print('        SCORE {}  BOX {}'.format(r['score'], r['box']))
+                print('        CAP {}\n'.format(r['cap']))
+
+            results_dict[img_path].append(r)
+
+        if console_args.extract:
+            box_num = len(results['boxes'])
+            h['feats'][start_idx: start_idx+box_num] = results['feats'].cpu().numpy()
+            h['boxes'][start_idx: start_idx+box_num] = results['boxes'].cpu().numpy()
+            h['start_idx'][img_idx] = start_idx
+            h['end_idx'][img_idx] = start_idx + box_num - 1
+            start_idx += box_num
+            img_idx += 1
+
+    if console_args.extract:
+        h.close()
+        # save order of img to a txt
+        if len(img_list) > 1:
+            with open(os.path.join(console_args.result_dir, 'feat_img_mappings.txt'), 'w') as f:
+                for img_path in img_list:
+                    f.writelines(os.path.split(img_path)[1] + '\n')
+
+    if not os.path.exists(console_args.result_dir):
+        os.mkdir(console_args.result_dir)
+    with open(os.path.join(console_args.result_dir, 'result.json'), 'w') as f:
+        json.dump(results_dict, f, indent=2)
+
+    if console_args.verbose:
+        print('[INFO] result save to {}'.format(os.path.join(console_args.result_dir, 'result.json')))
+        if console_args.extract:
+            print('[INFO] feats save to {}'.format(os.path.join(console_args.result_dir, 'box_feats.h5')))
+            print('[INFO] order save to {}'.format(os.path.join(console_args.result_dir, 'feat_img_mappings.txt')))
+
+
+def validate_box_feat(model, all_results, device, console_args):
+
+    with torch.no_grad():
+
+        box_describer = model.roi_heads.box_describer
+        box_describer.to(device)
+        box_describer.eval()
+
+        if console_args.verbose:
+            print('[INFO] start validating box features...')
+        for results in tqdm(all_results, disable=not console_args.verbose):
+
+            captions = box_describer(results['feats'].to(device))
+
+            assert (captions.cpu() == results['caps']).all().item(), 'caption mismatch'
+
+    if console_args.verbose:
+        print('[INFO] validate box feat done, no problem')
+
+
+def main(console_args):
+    global model
+    global first_run
+    device = torch.device("cuda" if torch.cuda.is_available() and not args.cpu else "cpu")
+
+    # === prepare images ====
+    img_list = get_image_path(console_args)
+
+    # === prepare model ====
+    if first_run:
+        model = load_model(console_args)
+        first_run = False
+
+    # === inference ====
+    all_results = describe_images(model, img_list, device, console_args)
+
+    # === save results ====
+    save_results_to_file(img_list, all_results, console_args)
+
+    if console_args.extract and console_args.check:
+        validate_box_feat(model, all_results, device, console_args)
+
+
+def process_image(image, folder_location):
+    global args
+    parser = argparse.ArgumentParser(description='Do dense captioning')
+    parser.add_argument('--config_json', type=str, help="path of the json file which stored model configuration")
+    parser.add_argument('--lut_path', type=str, default=f'{folder_location}CircumSpect/data/VG-regions-dicts-lite.pkl', help='look up table path')
+    parser.add_argument('--model_checkpoint', type=str, help="path of the trained model checkpoint")
+    parser.add_argument('--img_path', type=str, help="path of images, should be a file or a directory with only images")
+    parser.add_argument('--result_dir', type=str, default='.',
+                        help="path of the directory to save the output file")
+    parser.add_argument('--box_per_img', type=int, default=100, help='max boxes to describe per image')
+    parser.add_argument('--batch_size', type=int, default=1, help="useful when img_path is a directory")
+    parser.add_argument('--extract', action='store_true', help='whether to extract features')
+    parser.add_argument('--cpu', action='store_true', help='whether use cpu to compute')
+    parser.add_argument('--verbose', action='store_true', help='whether output info')
+    parser.add_argument('--check', action='store_true', help='whether to validate box feat by regenerate sentences')
+    args = argparse.Namespace()
+
+    args.config_json = f'{folder_location}CircumSpect/model_params/train_all_val_all_bz_2_epoch_10_inject_init/config.json'
+    args.lut_path = f'{folder_location}CircumSpect/data/VG-regions-dicts-lite.pkl'
+    args.model_checkpoint = f'{folder_location}models/train_all_val_all_bz_2_epoch_10_inject_init.pth.tar'
+    args.img_path = image
+    args.result_dir = f'{folder_location}CircumSpect/'
+    args.box_per_img = 100
+    args.batch_size = 2
+    args.extract = False
+    args.cpu = False
+    args.verbose = True
+    args.check = False
+
+    main(args)

evaluate.py

@@ -0,0 +1,83 @@
+import torch
+from tqdm import tqdm
+
+from utils.data_loader import DenseCapDataset, DataLoaderPFG
+from model.evaluator import DenseCapEvaluator
+
+
+def quality_check(model, dataset, idx_to_token, device, max_iter=-1):
+
+    model.to(device)
+    data_loader = DataLoaderPFG(dataset, batch_size=1, shuffle=False, num_workers=1,
+                                 pin_memory=True, collate_fn=DenseCapDataset.collate_fn)
+
+    print('[quality check]')
+    for i, (img, targets, info) in enumerate(data_loader):
+
+        img = [img_tensor.to(device) for img_tensor in img]
+        targets = [{k: v.to(device) for k, v in target.items()} for target in targets]
+
+        with torch.no_grad():
+            model.eval()
+            model.return_features = False
+            detections = model(img)
+
+        for j in range(len(targets)):
+            print('<{}>'.format(info[j]['file_name']))
+            print('=== ground truth ===')
+            for box, cap, cap_len in zip(targets[j]['boxes'], targets[j]['caps'], targets[j]['caps_len']):
+                print('box:', box.tolist())
+                print('len:', cap_len.item())
+                print('cap:', ' '.join(idx_to_token[idx] for idx in cap.tolist() if idx_to_token[idx] != '<pad>'))
+                print('-'*20)
+
+            print('=== predict ===')
+            for box, cap, score in zip(detections[j]['boxes'], detections[j]['caps'], detections[j]['scores']):
+                print('box:', [round(c, 2) for c in box.tolist()])
+                print('score:', round(score.item(), 2))
+                print('cap:', ' '.join(idx_to_token[idx] for idx in cap.tolist() if idx_to_token[idx] != '<pad>'))
+                print('-'*20)
+
+        if i >= max_iter > 0:
+            break
+
+
+def quantity_check(model, dataset, idx_to_token, device, max_iter=-1, verbose=True):
+
+    model.to(device)
+    data_loader = DataLoaderPFG(dataset, batch_size=4, shuffle=False, num_workers=2,
+                                 pin_memory=True, collate_fn=DenseCapDataset.collate_fn)
+
+    evaluator = DenseCapEvaluator(list(model.roi_heads.box_describer.special_idx.keys()))
+
+    print('[quantity check]')
+    for i, (img, targets, info) in tqdm(enumerate(data_loader), total=len(data_loader)):
+
+        img = [img_tensor.to(device) for img_tensor in img]
+        targets = [{k: v.to(device) for k, v in target.items()} for target in targets]
+
+        with torch.no_grad():
+            model.eval()
+            model.return_features = False
+            detections = model(img)
+
+        for j in range(len(targets)):
+            scores = detections[j]['scores']
+            boxes = detections[j]['boxes']
+            text = [' '.join(idx_to_token[idx] for idx in cap.tolist() if idx_to_token[idx] != '<pad>')
+                    for cap in detections[j]['caps']]
+            target_boxes = targets[j]['boxes']
+            target_text = [' '.join(idx_to_token[idx] for idx in cap.tolist() if idx_to_token[idx] != '<pad>')
+                    for cap in targets[j]['caps']]
+            img_id = info[j]['file_name']
+
+            evaluator.add_result(scores, boxes, text, target_boxes, target_text, img_id)
+
+        if i >= max_iter > 0:
+            break
+
+    results = evaluator.evaluate(verbose)
+    if verbose:
+        print('MAP: {:.3f} DET_MAP: {:.3f}'.format(results['map'], results['detmap']))
+
+    return results

faces.py

@@ -0,0 +1,84 @@
+import face_recognition
+from PIL import Image
+import numpy as np
+import pickle
+import cv2
+import os
+
+with open('pwd.txt', 'r') as pwd:
+    folder_location = pwd.read()
+
+def find_encodings(images_):
+    encode_list = []
+    for imgs in images_:
+        imgs = np.array(Image.open('./img/face_recognition/'+imgs))
+        imgs = cv2.cvtColor(imgs, cv2.COLOR_BGR2RGB)
+        encode = face_recognition.face_encodings(imgs)[0]
+        encode_list.append(encode)
+    return encode_list
+
+def recognize_users(cap):
+    path = f'{folder_location}img/face_recognition'
+    recognized_users = []  # List to store names of recognized users
+    images = []
+    classNames = []
+    myList = os.listdir(path)
+
+    for cl in myList:
+        curImg = cv2.imread(f'{path}/{cl}')
+        images.append(curImg)
+        classNames.append(os.path.splitext(cl)[0])
+    try:
+        with open(f'{folder_location}models/face_rec', 'rb') as file:
+            encodeListKnown = pickle.load(file)
+    except:
+        path = f'{folder_location}img/face_recognition'
+        images = []
+        classNames = []
+        myList = os.listdir(path)
+        images = myList
+
+        encodeListKnown = find_encodings(images)
+        print(len(encodeListKnown))
+        print('Encoding Complete')
+
+        with open(f'{folder_location}models/face_rec', 'wb') as file:
+            pickle.dump(encodeListKnown, file)
+            file.close()
+
+    _, img = cap.read()
+    img = cv2.flip(img, 2)
+    imgS = cv2.resize(img, (0,0), None, 0.25, 0.25)
+    imgS = cv2.cvtColor(imgS, cv2.COLOR_BGR2RGB)
+    
+    facesCurFrame = face_recognition.face_locations(imgS)
+    encodeCurFrame = face_recognition.face_encodings(imgS, facesCurFrame)
+
+    for encodeFace, faceLoc in zip(encodeCurFrame, facesCurFrame):
+        matches = face_recognition.compare_faces(encodeListKnown, encodeFace)
+        faceDis = face_recognition.face_distance(encodeListKnown, encodeFace)
+        print(faceDis)
+        matchIndices = np.where(matches)[0]  # Get indices of all matched faces
+        
+        for matchIndex in matchIndices:
+            name = classNames[matchIndex].upper()
+            recognized_users.append(name)  # Append recognized user to the list
+            print(name)
+            y1, x2, y2, x1 = faceLoc
+            y1, x2, y2, x1 = y1*4, x2*4, y2*4, x1*4
+            cv2.rectangle(img, (x1, y1), (x2, y2), (205, 154, 79), 2)
+            cv2.putText(img, name, (x1+6, y2-6), cv2.FONT_HERSHEY_COMPLEX, 0.7, (255, 255, 255), 2)
+        
+        if not matchIndices.all():
+            name = "UNKNOWN"
+            print(name)
+            y1, x2, y2, x1 = faceLoc
+            y1, x2, y2, x1 = y1*4, x2*4, y2*4, x1*4
+            cv2.rectangle(img, (x1, y1), (x2, y2), (205, 154, 79))
+            cv2.putText(img, 'UNKNOWN', (x1+6, y2-6), cv2.FONT_HERSHEY_COMPLEX, 0.7, (255, 255, 255), 2)
+
+    # cv2.imshow("Face Recognition", img)
+    # cv2.waitKey(1)
+
+    return recognized_users, img
+