testing git upload

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2022-2022 dinesh reddy and others
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

app.py

@@ -1,17 +1,57 @@
 import numpy as np
 
 import gradio as gr
+from infer import detections
 
-def sepia(input_img):
-    sepia_filter = np.array(
-        [[0.393, 0.769, 0.189], [0.349, 0.686, 0.168], [0.272, 0.534, 0.131]]
-    )
-    sepia_img = input_img.dot(sepia_filter.T)
-    sepia_img /= sepia_img.max()
-    return sepia_img
+def walt_demo(input_img):
+    #detect_people = detections('configs/walt/walt_people.py', 'cuda:0', model_path='data/models/walt_people.pth')
+    detect = detections('configs/walt/walt_vehicle.py', 'cuda:0', model_path='data/models/walt_vehicle.pth')
+    count = 0
+    #img = detect_people.run_on_image(input_img)
+    output_img = detect.run_on_image(input_img)
+    #try:
+    #except:
+    #    print("detecting on image failed")
 
-demo = gr.Interface(sepia, gr.Image(shape=(200, 200)), "image")
+    return output_img
 
-demo.launch()
+description = """
+WALT Demo on WALT dataset. After watching and automatically learning for several days, this approach shows significant performance improvement in detecting and segmenting occluded people and vehicles, over human-supervised amodal approaches</b>.
+<center>
+    <a href="https://www.cs.cmu.edu/~walt/">
+        <img style="display:inline" alt="Project page" src="https://img.shields.io/badge/Project%20Page-WALT-green">
+    </a>
+    <a href="https://www.cs.cmu.edu/~walt/pdf/walt.pdf"><img style="display:inline" src="https://img.shields.io/badge/Paper-Pdf-red"></a>
+    <a href="https://github.com/dineshreddy91/WALT"><img style="display:inline" src="https://img.shields.io/github/stars/dineshreddy91/WALT?style=social"></a>
+</center>
+"""
+title = "WALT:Watch And Learn 2D Amodal Representation using Time-lapse Imagery"
+article="""
+<center>
+    <img src='https://visitor-badge.glitch.me/badge?page_id=anhquancao.MonoScene&left_color=darkmagenta&right_color=purple' alt='visitor badge'>
+</center>
+"""
+
+examples = [
+    'demo/images/img_1.jpg',
+]
+
+
+import cv2
+filename='demo/images/img_1.jpg'
+img=cv2.imread(filename)
+img=walt_demo(img)
+cv2.imwrite(filename.replace('demo','demo/results/'),img)
+
+demo = gr.Interface(walt_demo, 
+        gr.Image(), 
+        "image",
+        article=article,
+        title=title,
+        enable_queue=True,
+        examples=examples,
+        description=description)
+
+demo.launch(server_name="0.0.0.0", server_port=7000)
 
 

cwalt/CWALT.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Tue Oct 19 19:14:47 2021
+
+@author: dinesh
+"""
+import glob
+from .utils import bb_intersection_over_union_unoccluded
+import numpy as np
+from PIL import Image
+import datetime
+import cv2
+import os
+from tqdm import tqdm
+
+
+def get_image(time, folder):
+    for week_loop in range(5):
+        try:
+            image = np.array(Image.open(folder+'/week' +str(week_loop)+'/'+ str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg'))                
+            break
+        except:
+            continue
+    if image is None:
+        print('file not found')
+    return image
+
+def get_mask(segm, image):
+    poly = np.array(segm).reshape((int(len(segm)/2), 2))
+    mask = image.copy()*0
+    cv2.fillConvexPoly(mask, poly, (255, 255, 255))
+    return mask
+
+def get_unoccluded(indices, tracks_all):
+    unoccluded_indexes = []
+    unoccluded_index_all =[]
+    while 1:
+        unoccluded_clusters = []
+        len_unocc = len(unoccluded_indexes)
+        for ind in indices:
+            if ind in unoccluded_indexes:
+                continue
+            occ = False
+            for ind_compare in indices:
+                if ind_compare in unoccluded_indexes:
+                    continue
+                if bb_intersection_over_union_unoccluded(tracks_all[ind], tracks_all[ind_compare]) > 0.01 and ind_compare != ind:
+                    occ = True
+            if occ==False:
+                unoccluded_indexes.extend([ind])
+                unoccluded_clusters.extend([ind])
+        if len(unoccluded_indexes) == len_unocc and len_unocc != 0:
+            for ind in indices:
+                if ind not in unoccluded_indexes:
+                    unoccluded_indexes.extend([ind])
+                    unoccluded_clusters.extend([ind])
+            
+        unoccluded_index_all.append(unoccluded_clusters)
+        if len(unoccluded_indexes) > len(indices)-5:
+            break
+    return unoccluded_index_all
+
+def primes(n): # simple sieve of multiples 
+   odds = range(3, n+1, 2)
+   sieve = set(sum([list(range(q*q, n+1, q+q)) for q in odds], []))
+   return [2] + [p for p in odds if p not in sieve]
+
+def save_image(image_read, save_path, data, path):
+        tracks = data['tracks_all_unoccluded']
+        segmentations = data['segmentation_all_unoccluded']
+        timestamps = data['timestamps_final_unoccluded']
+
+        image = image_read.copy()
+        indices = np.random.randint(len(tracks),size=30)
+        prime_numbers = primes(1000)
+        unoccluded_index_all = get_unoccluded(indices, tracks)
+        
+        mask_stacked = image*0
+        mask_stacked_all =[]
+        count = 0
+        time = datetime.datetime.now()
+
+        for l in indices:
+                try:
+                    image_crop = get_image(timestamps[l], path)
+                except:
+                    continue
+                try:
+                    bb_left, bb_top, bb_width, bb_height, confidence = tracks[l]
+                except:
+                    bb_left, bb_top, bb_width, bb_height, confidence, track_id = tracks[l]
+                mask = get_mask(segmentations[l], image)
+                
+                image[mask > 0] = image_crop[mask > 0]
+                mask[mask > 0] = 1
+                for count, mask_inc in enumerate(mask_stacked_all):
+                    mask_stacked_all[count][cv2.bitwise_and(mask, mask_inc) > 0] = 2
+                mask_stacked_all.append(mask)
+                mask_stacked += mask
+                count = count+1
+        
+        cv2.imwrite(save_path + '/images/'+str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg', image[:, :, ::-1])
+        cv2.imwrite(save_path + '/Segmentation/'+str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg', mask_stacked[:, :, ::-1]*30)
+        np.savez_compressed(save_path+'/Segmentation/'+str(time).replace(' ','T').replace(':','-').split('+')[0], mask=mask_stacked_all)
+        
+def CWALT_Generation(camera_name):
+    save_path_train = 'data/cwalt_train'
+    save_path_test = 'data/cwalt_test'
+    
+    json_file_path = 'data/{}/{}.json'.format(camera_name,camera_name) # iii1/iii1_7_test.json' # './data.json'
+    path = 'data/' + camera_name
+    
+    data = np.load(json_file_path + '.npz', allow_pickle=True)
+    
+    ## slip data
+    
+    data_train=dict()
+    data_test=dict()
+    
+    split_index = int(len(data['timestamps_final_unoccluded'])*0.8)
+    
+    data_train['tracks_all_unoccluded'] = data['tracks_all_unoccluded'][0:split_index]
+    data_train['segmentation_all_unoccluded'] = data['segmentation_all_unoccluded'][0:split_index]
+    data_train['timestamps_final_unoccluded'] = data['timestamps_final_unoccluded'][0:split_index]
+    
+    data_test['tracks_all_unoccluded'] = data['tracks_all_unoccluded'][split_index:]
+    data_test['segmentation_all_unoccluded'] = data['segmentation_all_unoccluded'][split_index:]
+    data_test['timestamps_final_unoccluded'] = data['timestamps_final_unoccluded'][split_index:]
+
+    image_read = np.array(Image.open(path + '/T18-median_image.jpg'))
+    image_read = cv2.resize(image_read, (int(image_read.shape[1]/2), int(image_read.shape[0]/2)))
+    
+    try:
+        os.mkdir(save_path_train)
+    except:
+        print(save_path_train)
+
+    try:
+        os.mkdir(save_path_train + '/images')
+        os.mkdir(save_path_train + '/Segmentation')
+    except:
+        print(save_path_train+ '/images')
+
+    try:
+        os.mkdir(save_path_test)
+    except:
+        print(save_path_test)
+
+    try:
+        os.mkdir(save_path_test + '/images')
+        os.mkdir(save_path_test + '/Segmentation')
+    except:
+        print(save_path_test+ '/images')
+
+    for loop in tqdm(range(3000), desc="Generating training CWALT Images "):
+        save_image(image_read, save_path_train, data_train, path)
+        
+    for loop in tqdm(range(300), desc="Generating testing CWALT Images "):
+        save_image(image_read, save_path_test, data_test, path)
+

cwalt/Clip_WALT_Generate.py

@@ -0,0 +1,284 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 20 15:15:11 2022
+
+@author: dinesh
+"""
+
+from collections import OrderedDict
+from matplotlib import pyplot as plt
+from .utils import *
+import scipy.interpolate
+
+from scipy import interpolate
+from .clustering_utils import *
+import glob
+import cv2
+from PIL import Image
+
+
+import json
+import cv2
+
+import numpy as np
+from tqdm import tqdm
+
+
+def ignore_indexes(tracks_all, labels_all):
+    # get repeating bounding boxes
+    get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x == y]
+    ignore_ind = []
+    for index, track in enumerate(tracks_all):
+        print('in ignore', index, len(tracks_all))
+        if index in ignore_ind:
+            continue
+
+        if labels_all[index] < 1 or labels_all[index] > 3:
+            ignore_ind.extend([index])            
+        
+        ind = get_indexes(track, tracks_all)
+        if len(ind) > 30:
+            ignore_ind.extend(ind)
+
+    return ignore_ind
+    
+def repeated_indexes_old(tracks_all,ignore_ind, unoccluded_indexes=None):
+    # get repeating bounding boxes
+    get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if bb_intersection_over_union(x, y) > 0.8 and i not in ignore_ind]
+    repeat_ind = []
+    repeat_inds =[]
+    if unoccluded_indexes == None:
+        for index, track in enumerate(tracks_all):
+            if index in repeat_ind or index in ignore_ind:
+                continue
+            ind = get_indexes(track, tracks_all)
+            if len(ind) > 20:
+                repeat_ind.extend(ind)
+                repeat_inds.append([ind,track])
+    else:
+        for index in unoccluded_indexes:
+            if index in repeat_ind or index in ignore_ind:
+                continue
+            ind = get_indexes(tracks_all[index], tracks_all)
+            if len(ind) > 3:
+                repeat_ind.extend(ind)
+                repeat_inds.append([ind,tracks_all[index]])
+    return repeat_inds
+
+def get_unoccluded_instances(timestamps_final, tracks_all, ignore_ind=[], threshold = 0.01):
+    get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x==y]
+    unoccluded_indexes = []
+    time_checked = []
+    stationary_obj = []
+    count =0 
+    
+    for time in tqdm(np.unique(timestamps_final), desc="Detecting Unocclued objects in Image "):
+        count += 1
+        if [time.year,time.month, time.day, time.hour, time.minute, time.second, time.microsecond] in time_checked:
+            analyze_bb = []
+            for ind in unoccluded_indexes_time:
+                for ind_compare in  same_time_instances:
+                    iou = bb_intersection_over_union(tracks_all[ind], tracks_all[ind_compare])
+                    if  iou < 0.5 and iou > 0:
+                        analyze_bb.extend([ind_compare])
+                    if iou > 0.99:
+                        stationary_obj.extend([str(ind_compare)+'+'+str(ind)])
+                        
+            for ind in  analyze_bb:
+                occ = False
+                for ind_compare in same_time_instances:
+                    if bb_intersection_over_union_unoccluded(tracks_all[ind], tracks_all[ind_compare], threshold=threshold) > threshold and ind_compare != ind:
+                        occ = True
+                        break
+                if occ == False:
+                    unoccluded_indexes.extend([ind])
+            continue
+        
+        same_time_instances = get_indexes(time,timestamps_final)
+        unoccluded_indexes_time = []
+
+        for ind in same_time_instances:
+            if tracks_all[ind][4] < 0.9 or ind in ignore_ind:# or ind != 1859:
+                continue
+            occ = False
+            for ind_compare in same_time_instances:
+                if bb_intersection_over_union_unoccluded(tracks_all[ind], tracks_all[ind_compare], threshold=threshold) > threshold and ind_compare != ind and tracks_all[ind_compare][4] < 0.5:
+                    occ = True
+                    break
+            if occ==False:
+                unoccluded_indexes.extend([ind])
+                unoccluded_indexes_time.extend([ind])
+        time_checked.append([time.year,time.month, time.day, time.hour, time.minute, time.second, time.microsecond])
+    return unoccluded_indexes,stationary_obj
+                                
+def visualize_unoccluded_detection(timestamps_final,tracks_all,segmentation_all,  unoccluded_indexes, cwalt_data_path, camera_name, ignore_ind=[]):            
+    tracks_final = []
+    tracks_final.append([])
+    try:
+        os.mkdir(cwalt_data_path + '/' + camera_name+'_unoccluded_car_detection/')
+    except:
+        print('Unoccluded debugging exists')
+            
+    for time in tqdm(np.unique(timestamps_final), desc="Visualizing Unocclued objects in Image "):
+        get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if x==y]
+        ind = get_indexes(time, timestamps_final)
+        image_unocc = False
+        for index in ind:
+            if index not in unoccluded_indexes:
+                continue
+            else:
+                image_unocc = True
+                break
+        if image_unocc == False:
+            continue
+            
+        for week_loop in range(5):
+            try:
+                image = np.array(Image.open(cwalt_data_path+'/week' +str(week_loop)+'/'+ str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg'))                
+                break
+            except:
+                continue
+            
+        try:
+            mask = image*0
+        except:
+            print('image not found for ' + str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg' )   
+            continue
+        image_original = image.copy()
+            
+        for index in ind:
+            track = tracks_all[index]
+
+            if index in ignore_ind:
+                continue
+            if index not in unoccluded_indexes:
+                continue
+            try:
+                bb_left, bb_top, bb_width, bb_height, confidence, id = track
+            except:
+                bb_left, bb_top, bb_width, bb_height, confidence = track
+
+            if confidence > 0.6:
+                mask = poly_seg(image, segmentation_all[index])
+        cv2.imwrite(cwalt_data_path +  '/' + camera_name+'_unoccluded_car_detection/' + str(index)+'.png', mask[:, :, ::-1])
+
+def repeated_indexes(tracks_all,ignore_ind, repeat_count = 10, unoccluded_indexes=None):
+    get_indexes = lambda x, xs: [i for (y, i) in zip(xs, range(len(xs))) if bb_intersection_over_union(x, y) > 0.8 and i not in ignore_ind]
+    repeat_ind = []
+    repeat_inds =[]
+    if unoccluded_indexes == None:
+        for index, track in enumerate(tracks_all):
+            if index in repeat_ind or index in ignore_ind:
+                continue
+
+            ind = get_indexes(track, tracks_all)
+            if len(ind) > repeat_count:
+                repeat_ind.extend(ind)
+                repeat_inds.append([ind,track])
+    else:
+        for index in unoccluded_indexes:
+            if index in repeat_ind or index in ignore_ind:
+                continue
+            ind = get_indexes(tracks_all[index], tracks_all)
+            if len(ind) > repeat_count:
+                repeat_ind.extend(ind)
+                repeat_inds.append([ind,tracks_all[index]])
+        
+
+    return repeat_inds
+
+def poly_seg(image, segm):
+    poly = np.array(segm).reshape((int(len(segm)/2), 2))
+    overlay = image.copy()
+    alpha = 0.5
+    cv2.fillPoly(overlay, [poly], color=(255, 255, 0))
+    cv2.addWeighted(overlay, alpha, image, 1 - alpha, 0, image)
+    return image
+
+def visualize_unoccuded_clusters(repeat_inds, tracks, segmentation_all, timestamps_final, cwalt_data_path):
+    for index_, repeat_ind in enumerate(repeat_inds):
+        image = np.array(Image.open(cwalt_data_path+'/'+'T18-median_image.jpg'))
+        try:        
+            os.mkdir(cwalt_data_path+ '/Cwalt_database/')
+        except:
+            print('folder exists')
+        try:
+            os.mkdir(cwalt_data_path+ '/Cwalt_database/' + str(index_) +'/')
+        except:
+            print(cwalt_data_path+ '/Cwalt_database/' + str(index_) +'/')
+            
+        for i in repeat_ind[0]:
+            try:
+                bb_left, bb_top, bb_width, bb_height, confidence = tracks[i]#bbox
+            except:
+                bb_left, bb_top, bb_width, bb_height, confidence, track_id = tracks[i]#bbox
+                    
+            cv2.rectangle(image,(int(bb_left), int(bb_top)),(int(bb_left+bb_width), int(bb_top+bb_height)),(0, 0, 255), 2)
+            time = timestamps_final[i]
+            for week_loop in range(5):
+                try:
+                    image1 = np.array(Image.open(cwalt_data_path+'/week' +str(week_loop)+'/'+ str(time).replace(' ','T').replace(':','-').split('+')[0] + '.jpg'))                
+                    break
+                except:
+                    continue
+                
+            crop = image1[int(bb_top): int(bb_top + bb_height), int(bb_left):int(bb_left + bb_width)]
+            cv2.imwrite(cwalt_data_path+ '/Cwalt_database/' + str(index_) +'/o_' + str(i) +'.jpg', crop[:, :, ::-1])
+            image1 = poly_seg(image1,segmentation_all[i])
+            crop = image1[int(bb_top): int(bb_top + bb_height), int(bb_left):int(bb_left + bb_width)]
+            cv2.imwrite(cwalt_data_path+ '/Cwalt_database/' + str(index_) +'/' + str(i)+'.jpg', crop[:, :, ::-1])
+        if index_ > 100:
+            break
+
+        cv2.imwrite(cwalt_data_path+ '/Cwalt_database/' +  str(index_) +'.jpg', image[:, :, ::-1])
+        
+def Get_unoccluded_objects(camera_name, debug = False, scale=True):
+    cwalt_data_path = 'data/' + camera_name
+    data_folder = cwalt_data_path
+    json_file_path = cwalt_data_path + '/' + camera_name + '.json'
+        
+    with open(json_file_path, 'r') as j:
+        annotations = json.loads(j.read())
+
+    tracks_all = [parse_bbox(anno['bbox']) for anno in annotations]
+    segmentation_all = [parse_bbox(anno['segmentation']) for anno in annotations]
+    labels_all = [anno['label_id'] for anno in annotations]
+    timestamps_final = [parse(anno['time']) for anno in annotations]
+    
+    if scale ==True:
+        scale_factor = 2
+        tracks_all_numpy = np.array(tracks_all)
+        tracks_all_numpy[:,:4] = np.array(tracks_all)[:,:4]/scale_factor
+        tracks_all = tracks_all_numpy.tolist()
+        
+        segmentation_all_scaled = []
+        for list_loop in segmentation_all:
+            segmentation_all_scaled.append((np.floor_divide(np.array(list_loop),scale_factor)).tolist())
+        segmentation_all = segmentation_all_scaled
+        
+    if debug == True:
+        timestamps_final = timestamps_final[:1000]
+        labels_all = labels_all[:1000]
+        segmentation_all = segmentation_all[:1000]
+        tracks_all = tracks_all[:1000]
+
+    unoccluded_indexes, stationary = get_unoccluded_instances(timestamps_final, tracks_all, threshold = 0.05)
+    if debug == True:
+        visualize_unoccluded_detection(timestamps_final, tracks_all, segmentation_all, unoccluded_indexes, cwalt_data_path, camera_name)
+    
+    tracks_all_unoccluded = [tracks_all[i] for i in unoccluded_indexes]
+    segmentation_all_unoccluded = [segmentation_all[i] for i in unoccluded_indexes]
+    labels_all_unoccluded = [labels_all[i] for i in unoccluded_indexes]
+    timestamps_final_unoccluded = [timestamps_final[i] for i in unoccluded_indexes]
+    np.savez(json_file_path,tracks_all_unoccluded=tracks_all_unoccluded, segmentation_all_unoccluded=segmentation_all_unoccluded, labels_all_unoccluded=labels_all_unoccluded, timestamps_final_unoccluded=timestamps_final_unoccluded )
+
+    if debug == True:
+        repeat_inds_clusters = repeated_indexes(tracks_all_unoccluded,[], repeat_count=1)
+        visualize_unoccuded_clusters(repeat_inds_clusters, tracks_all_unoccluded, segmentation_all_unoccluded, timestamps_final_unoccluded, cwalt_data_path)
+    else:
+        repeat_inds_clusters = repeated_indexes(tracks_all_unoccluded,[], repeat_count=10)
+
+    np.savez(json_file_path + '_clubbed', repeat_inds=repeat_inds_clusters)
+    np.savez(json_file_path + '_stationary', stationary=stationary)
+

cwalt/Download_Detections.py

@@ -0,0 +1,28 @@
+import json
+from psycopg2.extras import RealDictCursor
+#import cv2
+import psycopg2
+import cv2
+
+
+CONNECTION = "postgres://postgres:"
+
+conn = psycopg2.connect(CONNECTION)
+cursor = conn.cursor(cursor_factory=RealDictCursor)
+
+
+def get_sample():
+    camera_name, camera_id = 'cam2', 4
+    
+    print('Executing SQL command')
+
+    cursor.execute("SELECT * FROM annotations WHERE camera_id = {} and time >='2021-05-01 00:00:00' and time <='2021-05-07 23:59:50' and label_id in (1,2)".format(camera_id))
+
+    print('Dumping to json')
+    annotations = json.dumps(cursor.fetchall(), indent=2, default=str)
+    wjdata = json.loads(annotations)
+    with open('{}_{}_test.json'.format(camera_name, camera_id), 'w') as f:
+        json.dump(wjdata, f)
+    print('Done dumping to json')
+    
+get_sample()

cwalt/clustering_utils.py

@@ -0,0 +1,132 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 20 15:18:20 2022
+
+@author: dinesh
+"""
+
+# 0 - Import related libraries
+
+import urllib
+import zipfile
+import os
+import scipy.io
+import math
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+from scipy.spatial.distance import directed_hausdorff
+from sklearn.cluster import DBSCAN
+from sklearn.metrics.pairwise import pairwise_distances
+import scipy.spatial.distance
+
+from .kmedoid import kMedoids # kMedoids code is adapted from https://github.com/letiantian/kmedoids
+
+# Some visualization stuff, not so important
+# sns.set()
+plt.rcParams['figure.figsize'] = (12, 12)
+
+# Utility Functions
+
+color_lst = plt.rcParams['axes.prop_cycle'].by_key()['color']
+color_lst.extend(['firebrick', 'olive', 'indigo', 'khaki', 'teal', 'saddlebrown',
+                  'skyblue', 'coral', 'darkorange', 'lime', 'darkorchid', 'dimgray'])
+
+
+def plot_cluster(image, traj_lst, cluster_lst):
+    '''
+    Plots given trajectories with a color that is specific for every trajectory's own cluster index.
+    Outlier trajectories which are specified with -1 in `cluster_lst` are plotted dashed with black color
+    '''
+    cluster_count = np.max(cluster_lst) + 1
+
+    for traj, cluster in zip(traj_lst, cluster_lst):
+
+        # if cluster == -1:
+        #     # Means it it a noisy trajectory, paint it black
+        #     plt.plot(traj[:, 0], traj[:, 1], c='k', linestyle='dashed')
+        #
+        # else:
+        plt.plot(traj[:, 0], traj[:, 1], c=color_lst[cluster % len(color_lst)])
+
+    plt.imshow(image)
+    # plt.show()
+    plt.axis('off')
+    plt.savefig('trajectory.png', bbox_inches='tight')
+    plt.show()
+
+
+# 3 - Distance matrix
+
+def hausdorff( u, v):
+    d = max(directed_hausdorff(u, v)[0], directed_hausdorff(v, u)[0])
+    return d
+
+
+def build_distance_matrix(traj_lst):
+    # 2 - Trajectory segmentation
+
+    print('Running trajectory segmentation...')
+    degree_threshold = 5
+
+    for traj_index, traj in enumerate(traj_lst):
+
+        hold_index_lst = []
+        previous_azimuth = 1000
+
+        for point_index, point in enumerate(traj[:-1]):
+            next_point = traj[point_index + 1]
+            diff_vector = next_point - point
+            azimuth = (math.degrees(math.atan2(*diff_vector)) + 360) % 360
+
+            if abs(azimuth - previous_azimuth) > degree_threshold:
+                hold_index_lst.append(point_index)
+                previous_azimuth = azimuth
+        hold_index_lst.append(traj.shape[0] - 1)  # Last point of trajectory is always added
+
+        traj_lst[traj_index] = traj[hold_index_lst, :]
+
+    print('Building distance matrix...')
+    traj_count = len(traj_lst)
+    D = np.zeros((traj_count, traj_count))
+
+    # This may take a while
+    for i in range(traj_count):
+        if i % 20 == 0:
+            print(i)
+        for j in range(i + 1, traj_count):
+            distance = hausdorff(traj_lst[i], traj_lst[j])
+            D[i, j] = distance
+            D[j, i] = distance
+
+    return D
+
+
+def run_kmedoids(image, traj_lst, D):
+    # 4 - Different clustering methods
+
+    # 4.1 - kmedoids
+
+    traj_count = len(traj_lst)
+
+    k = 3  # The number of clusters
+    medoid_center_lst, cluster2index_lst = kMedoids(D, k)
+
+    cluster_lst = np.empty((traj_count,), dtype=int)
+
+    for cluster in cluster2index_lst:
+        cluster_lst[cluster2index_lst[cluster]] = cluster
+
+    plot_cluster(image, traj_lst, cluster_lst)
+
+
+def run_dbscan(image, traj_lst, D):
+    mdl = DBSCAN(eps=400, min_samples=10)
+    cluster_lst = mdl.fit_predict(D)
+
+    plot_cluster(image, traj_lst, cluster_lst)
+
+
+

cwalt/kmedoid.py

@@ -0,0 +1,55 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 20 15:18:56 2022
+
+@author: dinesh
+"""
+
+import numpy as np
+import math
+
+def kMedoids(D, k, tmax=100):
+    # determine dimensions of distance matrix D
+    m, n = D.shape
+
+    np.fill_diagonal(D, math.inf)
+
+    if k > n:
+        raise Exception('too many medoids')
+    # randomly initialize an array of k medoid indices
+    M = np.arange(n)
+    np.random.shuffle(M)
+    M = np.sort(M[:k])
+
+    # create a copy of the array of medoid indices
+    Mnew = np.copy(M)
+
+    # initialize a dictionary to represent clusters
+    C = {}
+    for t in range(tmax):
+        # determine clusters, i. e. arrays of data indices
+        J = np.argmin(D[:,M], axis=1)
+
+        for kappa in range(k):
+            C[kappa] = np.where(J==kappa)[0]
+        # update cluster medoids
+        for kappa in range(k):
+            J = np.mean(D[np.ix_(C[kappa],C[kappa])],axis=1)
+            j = np.argmin(J)
+            Mnew[kappa] = C[kappa][j]
+        np.sort(Mnew)
+        # check for convergence
+        if np.array_equal(M, Mnew):
+            break
+        M = np.copy(Mnew)
+    else:
+        # final update of cluster memberships
+        J = np.argmin(D[:,M], axis=1)
+        for kappa in range(k):
+            C[kappa] = np.where(J==kappa)[0]
+
+    np.fill_diagonal(D, 0)
+
+    # return results
+    return M, C

cwalt/utils.py

@@ -0,0 +1,168 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Fri May 20 15:16:56 2022
+
+@author: dinesh
+"""
+
+import json
+import cv2
+from PIL import Image
+import numpy as np
+from dateutil.parser import parse
+
+def bb_intersection_over_union(box1, box2):
+    #print(box1, box2)
+    boxA = box1.copy()
+    boxB = box2.copy()
+    boxA[2] = boxA[0]+boxA[2]
+    boxA[3] = boxA[1]+boxA[3]
+    boxB[2] = boxB[0]+boxB[2]
+    boxB[3] = boxB[1]+boxB[3]
+    # determine the (x, y)-coordinates of the intersection rectangle
+    xA = max(boxA[0], boxB[0])
+    yA = max(boxA[1], boxB[1])
+    xB = min(boxA[2], boxB[2])
+    yB = min(boxA[3], boxB[3])
+
+    # compute the area of intersection rectangle
+    interArea = abs(max((xB - xA, 0)) * max((yB - yA), 0))
+    
+    if interArea == 0:
+        return 0
+    # compute the area of both the prediction and ground-truth
+    # rectangles
+    boxAArea = abs((boxA[2] - boxA[0]) * (boxA[3] - boxA[1]))
+    boxBArea = abs((boxB[2] - boxB[0]) * (boxB[3] - boxB[1]))
+
+    # compute the intersection over union by taking the intersection
+    # area and dividing it by the sum of prediction + ground-truth
+    # areas - the interesection area
+    iou = interArea / float(boxAArea + boxBArea - interArea)
+    return iou
+
+def bb_intersection_over_union_unoccluded(box1, box2, threshold=0.01):
+    #print(box1, box2)
+    boxA = box1.copy()
+    boxB = box2.copy()
+    boxA[2] = boxA[0]+boxA[2]
+    boxA[3] = boxA[1]+boxA[3]
+    boxB[2] = boxB[0]+boxB[2]
+    boxB[3] = boxB[1]+boxB[3]
+    # determine the (x, y)-coordinates of the intersection rectangle
+    xA = max(boxA[0], boxB[0])
+    yA = max(boxA[1], boxB[1])
+    xB = min(boxA[2], boxB[2])
+    yB = min(boxA[3], boxB[3])
+
+    # compute the area of intersection rectangle
+    interArea = abs(max((xB - xA, 0)) * max((yB - yA), 0))
+    
+    if interArea == 0:
+        return 0
+    # compute the area of both the prediction and ground-truth
+    # rectangles
+    boxAArea = abs((boxA[2] - boxA[0]) * (boxA[3] - boxA[1]))
+    boxBArea = abs((boxB[2] - boxB[0]) * (boxB[3] - boxB[1]))
+
+    # compute the intersection over union by taking the intersection
+    # area and dividing it by the sum of prediction + ground-truth
+    # areas - the interesection area
+    iou = interArea / float(boxAArea + boxBArea - interArea)
+
+    #print(iou)
+    # return the intersection over union value
+    occlusion = False
+    if iou > threshold and iou < 1:
+        #print(boxA[3], boxB[3], boxB[1])
+        if boxA[3] < boxB[3]:# and boxA[3] > boxB[1]:
+            if boxB[2] > boxA[0]:# and boxB[2] < boxA[2]:
+                #print('first', (boxB[2] - boxA[0])/(boxA[2] - boxA[0]))
+                if (min(boxB[2],boxA[2]) - boxA[0])/(boxA[2] - boxA[0]) > threshold:
+                    occlusion = True
+                
+            if boxB[0] < boxA[2]: # boxB[0] > boxA[0] and 
+                #print('second', (boxA[2] - boxB[0])/(boxA[2] - boxA[0]))
+                if (boxA[2] - max(boxB[0],boxA[0]))/(boxA[2] - boxA[0]) > threshold:
+                    occlusion = True
+        if occlusion == False:
+            iou = iou*0
+            #asas
+    #    asas
+    #iou = 0.9 #iou*0
+    #print(box1, box2, iou, occlusion)
+    return iou
+def draw_tracks(image, tracks):
+    """
+    Draw on input image.
+
+    Args:
+        image (numpy.ndarray): image
+        tracks (list): list of tracks to be drawn on the image.
+
+    Returns:
+        numpy.ndarray: image with the track-ids drawn on it.
+    """
+
+    for trk in tracks:
+
+        trk_id = trk[1]
+        xmin = trk[2]
+        ymin = trk[3]
+        width = trk[4]
+        height = trk[5]
+
+        xcentroid, ycentroid = int(xmin + 0.5*width), int(ymin + 0.5*height)
+
+        text = "ID {}".format(trk_id)
+
+        cv2.putText(image, text, (xcentroid - 10, ycentroid - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)
+        cv2.circle(image, (xcentroid, ycentroid), 4, (0, 255, 0), -1)
+
+    return image
+
+
+def draw_bboxes(image, tracks):
+    """
+    Draw the bounding boxes about detected objects in the image.
+
+    Args:
+        image (numpy.ndarray): Image or video frame.
+        bboxes (numpy.ndarray): Bounding boxes pixel coordinates as (xmin, ymin, width, height)
+        confidences (numpy.ndarray): Detection confidence or detection probability.
+        class_ids (numpy.ndarray): Array containing class ids (aka label ids) of each detected object.
+
+    Returns:
+        numpy.ndarray: image with the bounding boxes drawn on it.
+    """
+
+    for trk in tracks:
+        xmin = int(trk[2])
+        ymin = int(trk[3])
+        width = int(trk[4])
+        height = int(trk[5])
+        clr = (np.random.randint(0, 255), np.random.randint(0, 255), np.random.randint(0, 255))
+        cv2.rectangle(image, (xmin, ymin), (xmin + width, ymin + height), clr, 2)
+
+    return image
+
+
+def num(v):
+    number_as_float = float(v)
+    number_as_int = int(number_as_float)
+    return number_as_int if number_as_float == number_as_int else number_as_float
+
+
+def parse_bbox(bbox_str):
+    bbox_list = bbox_str.strip('{').strip('}').split(',')
+    bbox_list = [num(elem) for elem in bbox_list]
+    return bbox_list
+
+def parse_seg(bbox_str):
+    bbox_list = bbox_str.strip('{').strip('}').split(',')
+    bbox_list = [num(elem) for elem in bbox_list]
+    ret = bbox_list  # []
+    # for i in range(0, len(bbox_list) - 1, 2):
+    #     ret.append((bbox_list[i], bbox_list[i + 1]))
+    return ret

cwalt_generate.py

@@ -0,0 +1,14 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Created on Sat Jun  4 16:55:58 2022
+
+@author: dinesh
+"""
+from cwalt.CWALT import CWALT_Generation
+from cwalt.Clip_WALT_Generate import Get_unoccluded_objects
+
+if __name__ == '__main__':
+    camera_name = 'cam2'
+    Get_unoccluded_objects(camera_name)
+    CWALT_Generation(camera_name)

infer.py

@@ -0,0 +1,114 @@
+from argparse import ArgumentParser
+
+from mmdet.apis import inference_detector, init_detector, show_result_pyplot
+from mmdet.core.mask.utils import encode_mask_results
+import numpy as np
+import mmcv
+import torch 
+from imantics import Polygons, Mask
+import json
+import os
+import cv2, glob
+
+class detections():
+    def __init__(self, cfg_path, device, model_path = 'data/models/walt_vehicle.pth'):
+        self.model = init_detector(cfg_path, model_path, device=device)
+        self.all_preds = []
+        self.all_scores = []
+        self.index = []
+        self.score_thr = 0.6
+        self.result = []
+        self.record_dict = {'model': cfg_path,'results': []}
+        self.detect_count = []
+
+
+    def run_on_image(self, image):
+        self.result = inference_detector(self.model, image)
+        image_labelled = self.model.show_result(image, self.result, score_thr=self.score_thr)
+        return image_labelled
+
+    def process_output(self, count):
+        result = self.result
+        infer_result = {'url': count,
+                        'boxes': [],
+                        'scores': [],
+                        'keypoints': [],
+                        'segmentation': [],
+                        'label_ids': [],
+                        'track': [],
+                        'labels': []}
+
+        if isinstance(result, tuple):
+            bbox_result, segm_result = result
+            #segm_result = encode_mask_results(segm_result)
+            if isinstance(segm_result, tuple):
+                segm_result = segm_result[0]  # ms rcnn
+        bboxes = np.vstack(bbox_result)
+        labels = [np.full(bbox.shape[0], i, dtype=np.int32) for i, bbox in enumerate(bbox_result)]
+
+        labels = np.concatenate(labels)
+        segms = None
+        if segm_result is not None and len(labels) > 0:  # non empty
+            segms = mmcv.concat_list(segm_result)
+            if isinstance(segms[0], torch.Tensor):
+                segms = torch.stack(segms, dim=0).detach().cpu().numpy()
+            else:
+                segms = np.stack(segms, axis=0)
+
+        for i, (bbox, label, segm) in enumerate(zip(bboxes, labels, segms)):
+            if bbox[-1].item() <0.3:
+                continue
+            box = [bbox[0].item(), bbox[1].item(), bbox[2].item(), bbox[3].item()]
+            polygons = Mask(segm).polygons()
+            
+            infer_result['boxes'].append(box)
+            infer_result['segmentation'].append(polygons.segmentation)
+            infer_result['scores'].append(bbox[-1].item())
+            infer_result['labels'].append(self.model.CLASSES[label])
+            infer_result['label_ids'].append(label)
+        self.record_dict['results'].append(infer_result)
+        self.detect_count = labels
+    
+    def write_json(self, filename):
+        with open(filename + '.json', 'w') as f:
+            json.dump(self.record_dict, f)
+
+ 
+def main():
+    detect_people = detections('configs/walt/walt_people.py', 'cuda:0', model_path='data/models/walt_people.pth')
+    detect = detections('configs/walt/walt_vehicle.py', 'cuda:0', model_path='data/models/walt_vehicle.pth')
+    filenames = sorted(glob.glob('demo/images/*'))
+    count = 0
+    for filename in filenames:
+        img=cv2.imread(filename)
+        try:
+            img = detect_people.run_on_image(img)
+            img = detect.run_on_image(img)
+        except:
+            continue
+        count=count+1
+
+        try: 
+            import os
+            os.makedirs(os.path.dirname(filename.replace('demo','demo/results/')))
+            os.mkdirs(os.path.dirname(filename))
+        except:
+            print('done')
+        cv2.imwrite(filename.replace('demo','demo/results/'),img)
+        if count == 30000:
+            break
+        try:
+            detect.process_output(count)
+        except:
+            continue
+    '''
+
+    np.savez('FC', a= detect.record_dict)
+    with open('check.json', 'w') as f:
+        json.dump(detect.record_dict, f)
+    detect.write_json('seq3')
+    asas
+    detect.process_output(0)
+    '''
+if __name__ == "__main__":
+    main()

test.py

@@ -0,0 +1,226 @@
+import argparse
+import os
+import warnings
+
+import mmcv
+import torch
+from mmcv import Config, DictAction
+from mmcv.cnn import fuse_conv_bn
+from mmcv.parallel import MMDataParallel, MMDistributedDataParallel
+from mmcv.runner import (get_dist_info, init_dist, load_checkpoint,
+                         wrap_fp16_model)
+
+from mmdet.apis import multi_gpu_test, single_gpu_test
+from walt.datasets import (build_dataloader, build_dataset,
+                            replace_ImageToTensor)
+from mmdet.models import build_detector
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(
+        description='MMDet test (and eval) a model')
+    parser.add_argument('config', help='test config file path')
+    parser.add_argument('checkpoint', help='checkpoint file')
+    parser.add_argument('--out', help='output result file in pickle format')
+    parser.add_argument(
+        '--fuse-conv-bn',
+        action='store_true',
+        help='Whether to fuse conv and bn, this will slightly increase'
+        'the inference speed')
+    parser.add_argument(
+        '--format-only',
+        action='store_true',
+        help='Format the output results without perform evaluation. It is'
+        'useful when you want to format the result to a specific format and '
+        'submit it to the test server')
+    parser.add_argument(
+        '--eval',
+        type=str,
+        nargs='+',
+        help='evaluation metrics, which depends on the dataset, e.g., "bbox",'
+        ' "segm", "proposal" for COCO, and "mAP", "recall" for PASCAL VOC')
+    parser.add_argument('--show', action='store_true', help='show results')
+    parser.add_argument(
+        '--show-dir', help='directory where painted images will be saved')
+    parser.add_argument(
+        '--show-score-thr',
+        type=float,
+        default=0.3,
+        help='score threshold (default: 0.3)')
+    parser.add_argument(
+        '--gpu-collect',
+        action='store_true',
+        help='whether to use gpu to collect results.')
+    parser.add_argument(
+        '--tmpdir',
+        help='tmp directory used for collecting results from multiple '
+        'workers, available when gpu-collect is not specified')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    parser.add_argument(
+        '--options',
+        nargs='+',
+        action=DictAction,
+        help='custom options for evaluation, the key-value pair in xxx=yyy '
+        'format will be kwargs for dataset.evaluate() function (deprecate), '
+        'change to --eval-options instead.')
+    parser.add_argument(
+        '--eval-options',
+        nargs='+',
+        action=DictAction,
+        help='custom options for evaluation, the key-value pair in xxx=yyy '
+        'format will be kwargs for dataset.evaluate() function')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+
+    if args.options and args.eval_options:
+        raise ValueError(
+            '--options and --eval-options cannot be both '
+            'specified, --options is deprecated in favor of --eval-options')
+    if args.options:
+        warnings.warn('--options is deprecated in favor of --eval-options')
+        args.eval_options = args.options
+    return args
+
+
+def main():
+    args = parse_args()
+
+    assert args.out or args.eval or args.format_only or args.show \
+        or args.show_dir, \
+        ('Please specify at least one operation (save/eval/format/show the '
+         'results / save the results) with the argument "--out", "--eval"'
+         ', "--format-only", "--show" or "--show-dir"')
+
+    if args.eval and args.format_only:
+        raise ValueError('--eval and --format_only cannot be both specified')
+
+    if args.out is not None and not args.out.endswith(('.pkl', '.pickle')):
+        raise ValueError('The output file must be a pkl file.')
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+    # import modules from string list.
+    if cfg.get('custom_imports', None):
+        from mmcv.utils import import_modules_from_strings
+        import_modules_from_strings(**cfg['custom_imports'])
+    # set cudnn_benchmark
+    if cfg.get('cudnn_benchmark', False):
+        torch.backends.cudnn.benchmark = True
+    cfg.model.pretrained = None
+    if cfg.model.get('neck'):
+        if isinstance(cfg.model.neck, list):
+            for neck_cfg in cfg.model.neck:
+                if neck_cfg.get('rfp_backbone'):
+                    if neck_cfg.rfp_backbone.get('pretrained'):
+                        neck_cfg.rfp_backbone.pretrained = None
+        elif cfg.model.neck.get('rfp_backbone'):
+            if cfg.model.neck.rfp_backbone.get('pretrained'):
+                cfg.model.neck.rfp_backbone.pretrained = None
+
+    # in case the test dataset is concatenated
+    samples_per_gpu = 7
+    if isinstance(cfg.data.test, dict):
+        cfg.data.test.test_mode = True
+        samples_per_gpu = cfg.data.test.pop('samples_per_gpu', 1)
+        if samples_per_gpu > 1:
+            # Replace 'ImageToTensor' to 'DefaultFormatBundle'
+            cfg.data.test.pipeline = replace_ImageToTensor(
+                cfg.data.test.pipeline)
+    elif isinstance(cfg.data.test, list):
+        for ds_cfg in cfg.data.test:
+            ds_cfg.test_mode = True
+        samples_per_gpu = max(
+            [ds_cfg.pop('samples_per_gpu', 1) for ds_cfg in cfg.data.test])
+        if samples_per_gpu > 1:
+            for ds_cfg in cfg.data.test:
+                ds_cfg.pipeline = replace_ImageToTensor(ds_cfg.pipeline)
+
+    # init distributed env first, since logger depends on the dist info.
+    if args.launcher == 'none':
+        distributed = False
+    else:
+        distributed = True
+        init_dist(args.launcher, **cfg.dist_params)
+
+    # build the dataloader
+    print(samples_per_gpu,cfg.data.workers_per_gpu,)
+    dataset = build_dataset(cfg.data.test)
+    data_loader = build_dataloader(
+        dataset,
+        samples_per_gpu=samples_per_gpu,
+        workers_per_gpu=cfg.data.workers_per_gpu,
+        dist=distributed,
+        shuffle=False)
+
+    # build the model and load checkpoint
+    cfg.model.train_cfg = None
+    model = build_detector(cfg.model, test_cfg=cfg.get('test_cfg'))
+    fp16_cfg = cfg.get('fp16', None)
+    if fp16_cfg is not None:
+        wrap_fp16_model(model)
+    checkpoint = load_checkpoint(model, args.checkpoint, map_location='cpu')
+    if args.fuse_conv_bn:
+        model = fuse_conv_bn(model)
+    # old versions did not save class info in checkpoints, this walkaround is
+    # for backward compatibility
+    if 'CLASSES' in checkpoint.get('meta', {}):
+        model.CLASSES = checkpoint['meta']['CLASSES']
+    else:
+        model.CLASSES = dataset.CLASSES
+
+    if not distributed:
+        model = MMDataParallel(model, device_ids=[0])
+        outputs = single_gpu_test(model, data_loader, args.show, args.show_dir,
+                                  args.show_score_thr)
+    else:
+        model = MMDistributedDataParallel(
+            model.cuda(),
+            device_ids=[torch.cuda.current_device()],
+            broadcast_buffers=False)
+        outputs = multi_gpu_test(model, data_loader, args.tmpdir,
+                                 args.gpu_collect)
+    import numpy as np
+
+    rank, _ = get_dist_info()
+    if rank == 0:
+        if args.out:
+            print(f'\nwriting results to {args.out}')
+            mmcv.dump(outputs, args.out)
+        kwargs = {} if args.eval_options is None else args.eval_options
+        if args.format_only:
+            dataset.format_results(outputs, **kwargs)
+        if args.eval:
+            eval_kwargs = cfg.get('evaluation', {}).copy()
+            # hard-code way to remove EvalHook args
+            for key in [
+                    'interval', 'tmpdir', 'start', 'gpu_collect', 'save_best',
+                    'rule'
+            ]:
+                eval_kwargs.pop(key, None)
+            eval_kwargs.update(dict(metric=args.eval, **kwargs))
+            data_evaluated = dataset.evaluate(outputs, **eval_kwargs)
+            np.save(args.checkpoint+'_new1', data_evaluated)
+            print(data_evaluated)
+
+            print(dataset.evaluate(outputs, **eval_kwargs))
+
+
+if __name__ == '__main__':
+    main()

train.py

@@ -0,0 +1,191 @@
+import argparse
+import copy
+import os
+import os.path as osp
+import time
+import warnings
+
+import mmcv
+import torch
+from mmcv import Config, DictAction
+from mmcv.runner import get_dist_info, init_dist
+from mmcv.utils import get_git_hash
+
+from mmdet import __version__
+from mmdet.apis import set_random_seed
+from mmdet.models import build_detector
+from mmdet.utils import collect_env, get_root_logger
+from walt.apis import train_detector
+from walt.datasets import build_dataset
+
+
+def parse_args():
+    parser = argparse.ArgumentParser(description='Train a detector')
+    parser.add_argument('config', help='train config file path')
+    parser.add_argument('--work-dir', help='the dir to save logs and models')
+    parser.add_argument(
+        '--resume-from', help='the checkpoint file to resume from')
+    parser.add_argument(
+        '--no-validate',
+        action='store_true',
+        help='whether not to evaluate the checkpoint during training')
+    group_gpus = parser.add_mutually_exclusive_group()
+    group_gpus.add_argument(
+        '--gpus',
+        type=int,
+        help='number of gpus to use '
+        '(only applicable to non-distributed training)')
+    group_gpus.add_argument(
+        '--gpu-ids',
+        type=int,
+        nargs='+',
+        help='ids of gpus to use '
+        '(only applicable to non-distributed training)')
+    parser.add_argument('--seed', type=int, default=None, help='random seed')
+    parser.add_argument(
+        '--deterministic',
+        action='store_true',
+        help='whether to set deterministic options for CUDNN backend.')
+    parser.add_argument(
+        '--options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file (deprecate), '
+        'change to --cfg-options instead.')
+    parser.add_argument(
+        '--cfg-options',
+        nargs='+',
+        action=DictAction,
+        help='override some settings in the used config, the key-value pair '
+        'in xxx=yyy format will be merged into config file. If the value to '
+        'be overwritten is a list, it should be like key="[a,b]" or key=a,b '
+        'It also allows nested list/tuple values, e.g. key="[(a,b),(c,d)]" '
+        'Note that the quotation marks are necessary and that no white space '
+        'is allowed.')
+    parser.add_argument(
+        '--launcher',
+        choices=['none', 'pytorch', 'slurm', 'mpi'],
+        default='none',
+        help='job launcher')
+    parser.add_argument('--local_rank', type=int, default=0)
+    args = parser.parse_args()
+    if 'LOCAL_RANK' not in os.environ:
+        os.environ['LOCAL_RANK'] = str(args.local_rank)
+
+    if args.options and args.cfg_options:
+        raise ValueError(
+            '--options and --cfg-options cannot be both '
+            'specified, --options is deprecated in favor of --cfg-options')
+    if args.options:
+        warnings.warn('--options is deprecated in favor of --cfg-options')
+        args.cfg_options = args.options
+
+    return args
+
+
+def main():
+    args = parse_args()
+
+    cfg = Config.fromfile(args.config)
+    if args.cfg_options is not None:
+        cfg.merge_from_dict(args.cfg_options)
+    # import modules from string list.
+    if cfg.get('custom_imports', None):
+        from mmcv.utils import import_modules_from_strings
+        import_modules_from_strings(**cfg['custom_imports'])
+    # set cudnn_benchmark
+    if cfg.get('cudnn_benchmark', False):
+        torch.backends.cudnn.benchmark = True
+
+    # work_dir is determined in this priority: CLI > segment in file > filename
+    if args.work_dir is not None:
+        # update configs according to CLI args if args.work_dir is not None
+        cfg.work_dir = args.work_dir
+    elif cfg.get('work_dir', None) is None:
+        # use config filename as default work_dir if cfg.work_dir is None
+        cfg.work_dir = osp.join('./work_dirs',
+                                osp.splitext(osp.basename(args.config))[0])
+
+    if args.resume_from is not None:
+        cfg.resume_from = args.resume_from
+    if args.gpu_ids is not None:
+        cfg.gpu_ids = args.gpu_ids
+    else:
+        cfg.gpu_ids = range(1) if args.gpus is None else range(args.gpus)
+
+    # init distributed env first, since logger depends on the dist info.
+    if args.launcher == 'none':
+        distributed = False
+    else:
+        distributed = True
+        init_dist(args.launcher, **cfg.dist_params)
+        # re-set gpu_ids with distributed training mode
+        _, world_size = get_dist_info()
+        cfg.gpu_ids = range(world_size)
+
+
+    # create work_dir
+    mmcv.mkdir_or_exist(osp.abspath(cfg.work_dir))
+    # dump config
+    cfg.dump(osp.join(cfg.work_dir, osp.basename(args.config)))
+    # init the logger before other steps
+    timestamp = time.strftime('%Y%m%d_%H%M%S', time.localtime())
+    log_file = osp.join(cfg.work_dir, f'{timestamp}.log')
+    logger = get_root_logger(log_file=log_file, log_level=cfg.log_level)
+
+    # init the meta dict to record some important information such as
+    # environment info and seed, which will be logged
+    meta = dict()
+    # log env info
+    env_info_dict = collect_env()
+    env_info = '\n'.join([(f'{k}: {v}') for k, v in env_info_dict.items()])
+    dash_line = '-' * 60 + '\n'
+    logger.info('Environment info:\n' + dash_line + env_info + '\n' +
+                dash_line)
+    meta['env_info'] = env_info
+    meta['config'] = cfg.pretty_text
+    # log some basic info
+    logger.info(f'Distributed training: {distributed}')
+    logger.info(f'Config:\n{cfg.pretty_text}')
+
+    # set random seeds
+    if args.seed is not None:
+        logger.info(f'Set random seed to {args.seed}, '
+                    f'deterministic: {args.deterministic}')
+        set_random_seed(args.seed, deterministic=args.deterministic)
+    cfg.seed = args.seed
+    meta['seed'] = args.seed
+    meta['exp_name'] = osp.basename(args.config)
+
+    model = build_detector(
+        cfg.model,
+        train_cfg=cfg.get('train_cfg'),
+        test_cfg=cfg.get('test_cfg'))
+
+    datasets = [build_dataset(cfg.data.train)]
+    if len(cfg.workflow) == 2:
+        val_dataset = copy.deepcopy(cfg.data.val)
+        val_dataset.pipeline = cfg.data.train.pipeline
+        datasets.append(build_dataset(val_dataset))
+    if cfg.checkpoint_config is not None:
+        # save mmdet version, config file content and class names in
+        # checkpoints as meta data
+        cfg.checkpoint_config.meta = dict(
+            mmdet_version=__version__ + get_git_hash()[:7],
+            CLASSES=datasets[0].CLASSES)
+
+    # add an attribute for visualization convenience
+    model.CLASSES = datasets[0].CLASSES
+    train_detector(
+        model,
+        datasets,
+        cfg,
+        distributed=distributed,
+        validate=(not args.no_validate),
+        timestamp=timestamp,
+        meta=meta)
+
+
+if __name__ == '__main__':
+    main()