{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# CIS 519 Final Project: Classifying Animal Images Using Vision Transformers\n## Wahub Ahmed, Ankith Pinnamaneni, Bailey Hirota\nSome information about our final project. ","metadata":{}},{"cell_type":"markdown","source":"## Imports","metadata":{}},{"cell_type":"code","source":"import argparse\nimport glob\nimport os\nimport sys\nimport time\nimport warnings\nimport json, codecs\nimport random\nimport matplotlib.pyplot as plt\nfrom scipy.optimize import linear_sum_assignment as linear_assignment\nimport math\n\nimport cycler\nfrom matplotlib import colors\nfrom matplotlib import pyplot as plt\nimport matplotlib.patches as patches\nimport tensorflow as tf\n# import humanfriendly\nimport numpy as np\nimport pandas as pd\nfrom PIL import Image, ImageFile, ImageFont, ImageDraw\nimport statistics\nfrom torch.utils.data import Dataset,DataLoader\nimport torch\n# import tensorflow.compat.v1 as tf \n# tf.disable_v2_behavior()\nfrom tqdm import tqdm\n%matplotlib inline\n\n# from CameraTraps.ct_utils import truncate_float\nprint('TensorFlow version:', tf.__version__)\nprint('Is GPU available? tf.test.is_gpu_available:', tf.test.is_gpu_available())","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:22:40.232587Z","iopub.execute_input":"2023-04-20T19:22:40.233699Z","iopub.status.idle":"2023-04-20T19:22:48.042685Z","shell.execute_reply.started":"2023-04-20T19:22:40.233592Z","shell.execute_reply":"2023-04-20T19:22:48.041550Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Load metadata information","metadata":{}},{"cell_type":"code","source":"def image_name_to_id(name):\n    return name.rstrip('.jpg')\n\ndef read_image(path):\n    with tf.io.gfile.GFile(path, 'rb') as f:\n        return np.array(Image.open(f))\n    \ndef read_json(path):\n    with tf.io.gfile.GFile(path) as f:\n        return json.load(f)\n    \ndef create_detection_map(annotations,mode=\"train\"):\n    \"\"\"Creates a dict mapping IDs ---> detections.\"\"\"\n\n    ann_map = {}\n    for image in annotations['images']:\n        if image['file'].split('/')[0] == mode:\n            ann_map[image['file'].split('/')[-1].rstrip('.jpg')] = image['detections']\n    return ann_map\n\n# TRAIN\nIMAGES_DIR_TRAIN = \"/kaggle/input/iwildcam2022-fgvc9/train/train\"\nBOX_ANNOTATION_FILE = \"/kaggle/input/iwildcam2022-fgvc9/metadata/metadata/iwildcam2022_mdv4_detections.json\"\nMASKS_DIR = \"/kaggle/input/iwildcam2022-fgvc9/instance_masks/instance_masks\"\n\nimages_train = tf.io.gfile.listdir(IMAGES_DIR_TRAIN)\n# The annotations file contains annotations for all images in train and test\nannotations = read_json(BOX_ANNOTATION_FILE)\ndetection_train_map = create_detection_map(annotations)\nimages_train_ids = list(detection_train_map.keys())\n\n#TEST\nIMAGES_DIR_TEST = \"/kaggle/input/iwildcam2022-fgvc9/test/test\"\nimages_test = tf.io.gfile.listdir(IMAGES_DIR_TEST)\ndetection_test_map = create_detection_map(annotations,mode=\"test\")\nimages_test_ids = list(detection_test_map.keys())\n\nprint(f'length of detection map for train = {len(detection_train_map)}\\nlength of detection map for test = {len(detection_test_map)}\\n')\nprint(f'length of images for train = {len(images_train)}\\nlength of images for test = {len(images_test)}\\n')\nprint(f'total annotations from megaDetector model = {len(annotations[\"images\"])}')","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:22:48.044305Z","iopub.execute_input":"2023-04-20T19:22:48.045378Z","iopub.status.idle":"2023-04-20T19:22:56.064840Z","shell.execute_reply.started":"2023-04-20T19:22:48.045338Z","shell.execute_reply":"2023-04-20T19:22:56.063835Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"with codecs.open(\"../input/iwildcam2022-fgvc9/metadata/metadata/iwildcam2022_train_annotations.json\", 'r',\n                 encoding='utf-8', errors='ignore') as f:\n    train_meta = json.load(f)\n    \nwith codecs.open(\"../input/iwildcam2022-fgvc9/metadata/metadata/iwildcam2022_test_information.json\", 'r',\n                 encoding='utf-8', errors='ignore') as f:\n    test_meta = json.load(f)\nseq_test = pd.DataFrame(test_meta['images'])\n#train_cat.columns = [ 'category_id', 'scientificName','family', 'genus']\ndisplay(seq_test)\nseq_train = pd.DataFrame(train_meta['images'])\n#train_cat.columns = [ 'category_id', 'scientificName','family', 'genus']\ndisplay(seq_train)","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:22:56.066098Z","iopub.execute_input":"2023-04-20T19:22:56.066544Z","iopub.status.idle":"2023-04-20T19:22:58.754619Z","shell.execute_reply.started":"2023-04-20T19:22:56.066470Z","shell.execute_reply":"2023-04-20T19:22:58.753522Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Show DATA","metadata":{}},{"cell_type":"code","source":"COLOR_CYCLER = cycler.cycler(color=['tab:blue', 'tab:green', 'tab:orange',\n                                    'tab:red', 'tab:purple'])\npd_example = seq_train[seq_train['seq_id'] == \"30048d32-7d42-11eb-8fb5-0242ac1c0002\"]\ndef  get_image_annotation(image, detection_annotations, categories,instance_id_image,ax):\n    \"\"\"Plot boxes and mask annotations for a given image.\n\n            Args:\n            image: An image array of shape [H, W, 3]\n            detection_annotations: A list of detections. Each detection is a dict\n              containing the keys 'category', 'bbox' and 'conf'.\n            categories: A dict mapping category IDs to names.\n            instance_id_image: An array of shape [H, W] containing the instance ID\n              at each pixel. IDs are expected to be 1-indexed, with 0 reserved for\n              the background.\"\"\"\n        \n    cycle_iter = COLOR_CYCLER()\n    image_height, image_width = image.shape[:2]\n    ax.imshow(image)\n    for i, annotation in enumerate(detection_annotations):\n        xmin, ymin, width, height = annotation['bbox']\n        xmin *= image_width\n        ymin *= image_height\n        width *= image_width\n        height *= image_height\n        color = next(cycle_iter)['color']\n        rect = patches.Rectangle((xmin, ymin), width, height,\n                                 linewidth=3, edgecolor=color, facecolor='none')\n        ax.add_patch(rect)\n        label = '{}:{:.2f}'.format(categories[annotation['category']],\n                                   annotation['conf'])\n        ax.text(xmin, ymin - 5, label, fontsize=30, color='white',\n                  bbox=dict(boxstyle='square,pad=0.0', facecolor=color, alpha=0.75,\n                            ec='none'))\n        r, g, b, _ = colors.to_rgba(color)\n        color_array = np.array([r, g, b]).reshape(1, 1, 3)\n        color_image = np.ones((image_height, image_width, 3)) * color_array\n        mask = (instance_id_image == (i + 1)).astype(np.float32)[:, :, np.newaxis]\n        color_mask = np.concatenate([color_image, mask], axis=2)\n        \n        ax.imshow(color_mask, alpha=0.5)\n    return color_mask\n        \ndef show_images_seq(data,detections,train = True):\n    rows = data.shape[0]\n    cols = data.shape[1]\n    fig, axs = plt.subplots(rows, dpi=80,  figsize=(rows*5, rows*5))\n    for i in range(rows):\n        image_name = data[\"file_name\"][i]\n        image_path = os.path.join(IMAGES_DIR_TRAIN if train else IMAGES_DIR_TEST, image_name)\n        image_id = image_name_to_id(image_name)\n        mask_path = os.path.join(MASKS_DIR, f'{image_id}.png')\n        image = read_image(image_path)\n        if (image_id not in detections) or (len(detections[image_id]) == 0) or ( not tf.io.gfile.exists(mask_path)):\n            plt.title(f'{image_name} missing detection data.')\n            axs[i].imshow(image)\n        else:\n            detection_annotations = detections[image_id]\n            instance_id_image = read_image(mask_path)\n            image = get_image_annotation(image,detection_annotations,annotations['detection_categories'],instance_id_image,axs[i])   \n            \n        axs[i].axis(\"off\")    \n    plt.show()\n            \nshow_images_seq(pd_example,detection_train_map)","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:22:58.756715Z","iopub.execute_input":"2023-04-20T19:22:58.757100Z","iopub.status.idle":"2023-04-20T19:23:03.849525Z","shell.execute_reply.started":"2023-04-20T19:22:58.757067Z","shell.execute_reply":"2023-04-20T19:23:03.848663Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"## Possible solutions include:\n* Solution 1: Iwildcam competition winners in 2021 counted the maximum number of bboxes per frame as part of their sequence.\n* Solution 2. The identified objects will be tracked using an object tracker, which gives each object a unique ID number.","metadata":{}},{"cell_type":"markdown","source":"### Solution 1: Maximum detections in sequence","metadata":{}},{"cell_type":"code","source":"def count_detections(row,detections):\n    image_id = row['file_name'].split('.')[0]\n    threshold = 0.85\n    count = 0\n    \n    for bbox in detections[image_id]:\n        if bbox['conf'] > threshold:\n            count += 1   \n    return count\n\ndef generate_zero_submission(seq_ids):\n    sub = pd.DataFrame(seq_ids, columns=['Id'])\n    sub['Predicted'] = 0\n    return sub\n","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:23:03.850542Z","iopub.execute_input":"2023-04-20T19:23:03.851492Z","iopub.status.idle":"2023-04-20T19:23:03.859802Z","shell.execute_reply.started":"2023-04-20T19:23:03.851444Z","shell.execute_reply":"2023-04-20T19:23:03.858321Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"seq_test[\"detections_count\"] = np.nan\nfor idx,row in tqdm(seq_test.iterrows()):\n    seq_test.at[idx, 'detections_count'] = count_detections(row,detection_test_map)\n\nsubmission_res_by_max = generate_zero_submission(seq_test.seq_id.unique())\nfor seq_id in tqdm(seq_test.seq_id.unique()):\n    max_count = seq_test[seq_test.seq_id == seq_id]['detections_count'].max()\n    submission_res_by_max.loc[submission_res_by_max.Id == seq_id, 'Predicted'] = max_count\n    \ndisplay(submission_res_by_max)\nprint(\"Final results:\")\nprint(max(submission_res_by_max.Predicted))\nsubmission_res_by_max.to_csv (r'res_by_max.csv', index = False, header=True) \n","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:23:03.861756Z","iopub.execute_input":"2023-04-20T19:23:03.862242Z","iopub.status.idle":"2023-04-20T19:24:53.274180Z","shell.execute_reply.started":"2023-04-20T19:23:03.862176Z","shell.execute_reply":"2023-04-20T19:24:53.272899Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"### Solution 2: using Object-Tracker-Model\n","metadata":{}},{"cell_type":"markdown","source":"#### Intro to Tracking\nTracking in deep learning is the task of predicting the positions of objects throughout a video using their spatial as well as temporal features. More technically, Tracking is getting the initial set of detections, assigning unique ids, and tracking them throughout frames of the video (or sequence of frames) feed while maintaining the assigned ids. Tracking is generally a two-step process:  \n    **1. A detection module for target localization: The module responsible for detecting and localization of the object in the frame using some object detector like YOLOv4, CenterNet, etc (In our case- the detections is given part of db).**  \n    **2. A motion predictor: This module is responsible for predicting the future motion of the object using its past information.**\n\n### Types of Trackers\n\n1. **Single Object Tracker**- These types of trackers track only a single object even if there are many other objects present in the frame. (We will not use here).\n2. **Multiple Object Tracker -**\nThese types of trackers can track multiple objects present in a frame. Some of the algorithms include DeepSORT, JDE, and CenterTrack which are very powerful algorithms and handle most of the challenges faced by trackers. (We will present the idea below).  \n\nDeepSORT: [arXiv:1703.07402](https://arxiv.org/abs/1703.07402)  \nCentroid: [centroid tracking](https://pyimagesearch.com/2018/07/23/simple-object-tracking-with-opencv/)","metadata":{}},{"cell_type":"markdown","source":"#### Centroid-Tracker using L2 Distance","metadata":{}},{"cell_type":"code","source":"                                                                                                                               #######  \nclass EuclideanDistTracker:\n    def __init__(self):\n        self.center_points = {}\n        self.id_count = 0\n    \n    def update(self, objects_rect):\n        \"\"\"\n        Parameters:\n        -----------\n        object_rect:  array of bounding box coordinates.\n        --------\n        Returns:\n            list containing [x,y,w,h,object_id].\n                x,y,w,h are the bounding box coordinates, and object_id is the id assigned to that particular bounding box.\n        --------\n        \"\"\"\n        # Objects boxes and ids\n        objects_bbs_ids = []\n\n        # Get center point of new object\n        for rect in objects_rect:\n            x, y, w, h = rect\n            cx,cy = (x+w)/2, (y+h)/2\n#             cx = (x + x + w) // 2 # Center x\n#             cy = (y + y + h) // 2 # Center y\n            # Find out if that object was detected already\n            same_object_detected = False\n            for id, pt in self.center_points.items():\n                dist = math.hypot(cx - pt[0], cy - pt[1])\n\n                if dist < 25:\n                    self.center_points[id] = (cx, cy)\n                    objects_bbs_ids.append([x, y, w, h, id])\n                    same_object_detected = True\n                    break\n\n            # New object is detected we assign the ID to that object\n            if same_object_detected is False:\n                self.center_points[self.id_count] = (cx, cy)\n                objects_bbs_ids.append([x, y, w, h, self.id_count])\n                self.id_count += 1\n\n        # Clean the dictionary by center points to remove IDS not used anymore\n        new_center_points = {}\n        for obj_bb_id in objects_bbs_ids:\n            _, _, _, _, object_id = obj_bb_id\n            center = self.center_points[object_id]\n            new_center_points[object_id] = center\n\n        # Update dictionary with IDs not used removed\n        self.center_points = new_center_points.copy()\n        return objects_bbs_ids\n    \ndef get_detections(detections_dict,height,width):\n    detections = []\n    for diction in detections_dict:\n        if diction['conf'] > 0.85:\n            detections.append(diction['bbox'])\n\n    return detections \n    \ntracker = EuclideanDistTracker()\nsubmission_res_by_tracks = generate_zero_submission(seq_test.seq_id.unique())\ni=0\nfor seq_id in tqdm(seq_test.seq_id.unique()):\n    tracker.__init__()\n    seq_frames = seq_test[seq_test.seq_id == seq_id].sort_values(by=['seq_frame_num']).reset_index( drop = True)\n    for _,frame in seq_frames.iterrows():\n        detections = get_detections(detection_test_map[frame['id']], frame['height'],frame['width'])\n        boxes_ids = tracker.update(detections)\n    if i < 3 and tracker.id_count > 1 :\n        display(seq_frames)\n        show_images_seq(seq_frames,detection_test_map,train=False)\n        print(f'id_count = {tracker.id_count}')\n        i+=1\n        \n    submission_res_by_tracks.loc[submission_res_by_tracks.Id == seq_id, 'Predicted'] = tracker.id_count\n\ndisplay(submission_res_by_tracks)\nprint(max(submission_res_by_tracks.Predicted))\nsubmission_res_by_tracks.to_csv (r'res_by_tracks.csv', index = False, header=True) \n","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:24:53.289631Z","iopub.execute_input":"2023-04-20T19:24:53.290138Z","iopub.status.idle":"2023-04-20T19:27:22.626389Z","shell.execute_reply.started":"2023-04-20T19:24:53.290094Z","shell.execute_reply":"2023-04-20T19:27:22.625272Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Centroid-Tracker using L1 (Manhattan) Distance","metadata":{}},{"cell_type":"code","source":"class L1DistTracker:\n    def __init__(self):\n        self.center_points = {}\n        self.id_count = 0\n    \n    def update(self, objects_rect):\n        \"\"\"\n        Parameters:\n        -----------\n        object_rect:  array of bounding box coordinates.\n        --------\n        Returns:\n            list containing [x,y,w,h,object_id].\n                x,y,w,h are the bounding box coordinates, and object_id is the id assigned to that particular bounding box.\n        --------\n        \"\"\"\n        # Objects boxes and ids\n        objects_bbs_ids = []\n\n        # Get center point of new object\n        for rect in objects_rect:\n            x, y, w, h = rect\n            cx,cy = x+w/2, y+h/2\n            # Find out if that object was detected already\n            same_object_detected = False\n            for id, pt in self.center_points.items():\n                dist = abs(cx - pt[0]) + abs(cy - pt[1])\n\n                if dist < 25:\n                    self.center_points[id] = (cx, cy)\n                    objects_bbs_ids.append([x, y, w, h, id])\n                    same_object_detected = True\n                    break\n\n            # New object is detected we assign the ID to that object\n            if same_object_detected is False:\n                self.center_points[self.id_count] = (cx, cy)\n                objects_bbs_ids.append([x, y, w, h, self.id_count])\n                self.id_count += 1\n\n        # Clean the dictionary by center points to remove IDS not used anymore\n        new_center_points = {}\n        for obj_bb_id in objects_bbs_ids:\n            _, _, _, _, object_id = obj_bb_id\n            center = self.center_points[object_id]\n            new_center_points[object_id] = center\n\n        # Update dictionary with IDs not used removed\n        self.center_points = new_center_points.copy()\n        return objects_bbs_ids\n    \ndef get_detections(detections_dict, height, width):\n    detections = []\n    for diction in detections_dict:\n        if diction['conf'] > 0.85:\n            detections.append(diction['bbox'])\n\n    return detections \n\ntracker = L1DistTracker()\nsubmission_res_by_tracks = generate_zero_submission(seq_test.seq_id.unique())\ni=0\nfor seq_id in tqdm(seq_test.seq_id.unique()):\n    tracker.__init__()\n    seq_frames = seq_test[seq_test.seq_id == seq_id].sort_values(by=['seq_frame_num']).reset_index(drop=True)\n    for _,frame in seq_frames.iterrows():\n        detections = get_detections(detection_test_map[frame['id']], frame['height'], frame['width'])\n        boxes_ids = tracker.update(detections)\n    if i < 3 and tracker.id_count > 1 :\n        display(seq_frames)\n        show_images_seq(seq_frames, detection_test_map, train=False)\n        print(f'id_count = {tracker.id_count}')\n        i += 1\n        \n    submission_res_by_tracks.loc[submission_res_by_tracks.Id == seq_id, 'Predicted'] = tracker.id_count\n\ndisplay(submission_res_by_tracks)\nprint(max(submission_res_by_tracks.Predicted))\nsubmission_res_by_tracks.to_csv(r'res_by_tracks.csv', index=False, header=True)\n","metadata":{"execution":{"iopub.status.busy":"2023-04-20T19:27:22.627780Z","iopub.execute_input":"2023-04-20T19:27:22.628386Z","iopub.status.idle":"2023-04-20T19:29:51.949257Z","shell.execute_reply.started":"2023-04-20T19:27:22.628352Z","shell.execute_reply":"2023-04-20T19:29:51.948050Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"#### Results: \n* As you remember, when the solution was the maximum number of consecutive identifications - the best result achieved:\n    - Private = 0.264, Public = 0.277\n\nNow with centroid-tracker model:\n* with the limit of conf>0.95 on the detections:    \n![image.png](attachment:fed2a0c8-97b3-4f18-b2e4-5265e0c6e6bf.png)  \n    - Private = 0.348  Public = 0.360\n* without the conf restriction on the detections:  \n![image.png](attachment:31805a26-a4f2-47d4-8f0e-297c12ff857f.png)\n    - Private = 0.595 Public = 0.604\n","metadata":{},"attachments":{"fed2a0c8-97b3-4f18-b2e4-5265e0c6e6bf.png":{"image/png":"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"},"31805a26-a4f2-47d4-8f0e-297c12ff857f.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"## Conclusion\n* It is obvious that the performance of the object tracker is not as good as the counting heuristic. There could be several reasons for this.\n- Also, in order to get better performance - we can produce the identifications ourselves by our own model.\n\n    * It makes sense that the counting heuristic works best because we are counting animals in this project and since they were taken with a cameratrap (which takes many pictures in sequence when it detects movement) it could be that in one frame all the animals that passed by in sequence were captured. Therefore, the simple and working solution is to count the maximum number of identifications in the sequence of images.\n","metadata":{}}]}