galaxy_separation_mrcnn/scripts/evaluate.py at master · sowmyakth/galaxy_separation_mrcnn · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
import os
import sys
import numpy as np
# import pickle
# import dill
# import random
import matplotlib; matplotlib.use('Agg')
matplotlib.rcParams['figure.subplot.wspace'] = 0.05
matplotlib.rcParams['figure.subplot.hspace'] = 0.05
import matplotlib.pyplot as plt
import h5py

# Root directory of the project
ROOT_DIR = '/home/users/sowmyak/NN_blend/Mask_RCNN'

# Directory to save logs and trained model
MODEL_DIR = os.path.join(ROOT_DIR, "logs")

# path to images
DATA_PATH = '/scratch/users/sowmyak/lavender'

CODE_PATH = '/home/users/sowmyak/NN_blend/scripts'
# MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_final_again20180608T2004/mask_rcnn_blend_final_again_0080.h5'
# MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_final_again20180608T2004/mask_rcnn_blend_final_again_0123.h5'
#MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_test20180717T1318/mask_rcnn_blend_test_0045.h5'
#MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_test_again20180718T2130/mask_rcnn_blend_test_again_0080.h5'
#MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_test_again20180719T1635/mask_rcnn_blend_test_again_0058.h5'
#MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_test_again220180721T0202/mask_rcnn_blend_test_again2_0044.h5'
MODEL_PATH = '/scratch/users/sowmyak/lavender/logs/blend_new_loss20180723T1101/mask_rcnn_blend_new_loss_0070.h5'
sys.path.append(CODE_PATH)
import display
#import train as train
import train2 as train
#import train_final_again as train
# Import Mask RCNN
sys.path.append(ROOT_DIR)  # To find local version of the library
from mrcnn.config import Config
from train import InputConfig
from mrcnn import utils
import mrcnn.model as modellib
from mrcnn import visualize
from mrcnn.model import log
# from mrcnn.model import log

#COCO_MODEL_PATH = os.path.join(ROOT_DIR, "mask_rcnn_coco.h5")


class InferenceConfig(InputConfig):
    GPU_COUNT = 1
    IMAGES_PER_GPU = 1

# image, image_meta, class_ids, bbox, mask, debl_image, mult_image
def overall_perfomance(model, dataset_val, inference_config):
    image_ids = dataset_val.image_ids# np.random.choice(dataset_val.image_ids, 10)
    APs = []
    for image_id in image_ids:
        # Load image and ground truth data
        image, image_meta, gt_class_id, gt_bbox, gt_mask, _, _ =\
            modellib.load_image_gt(dataset_val, inference_config,
                                   image_id, use_mini_mask=False)
        # molded_images = np.expand_dims(modellib.mold_image(image, inference_config), 0)
        # Run object detection
        results = model.detect([image], verbose=0)
        r = results[0]
        # Compute AP
        if (gt_mask.shape[-1] == 0) or (r['masks'].shape[-1] == 0):
            print(image_id, " skipped")
            continue
        AP, precisions, recalls, overlaps =\
            utils.compute_ap(gt_bbox, gt_class_id, gt_mask,
                             r["rois"], r["class_ids"], r["scores"], r['masks'])
        APs.append(AP)
    print("mAP: ", np.mean(APs))
    print("prec: ", np.mean(precisions))
    print("recall: ", np.mean(recalls))
    print("overlap: ", np.mean(overlaps))


def evaluate(dataset_val):
    # Compute VOC-Style mAP @ IoU=0.5
    # Running on 10 images. Increase for better accuracy.
    inference_config = InferenceConfig()
    # added for testing
    # Recreate the model in inference mode
    model = modellib.MaskRCNN(mode="inference",
                              config=inference_config,
                              model_dir=MODEL_DIR)

    # Get path to saved weights
    # Either set a specific path or find last trained weights
    # model_path = os.path.join(ROOT_DIR, ".h5 file name here")
    #model_path = model.find_last()[1]
    if MODEL_PATH:
        model_path = MODEL_PATH
    else:
        model_path = model.find_last()[1]
    # model_path = '/home/users/sowmyak/NN_blend/Mask_RCNN/logs/blend420180607T1217/mask_rcnn_blend4_0009.h5'
    # Load trained weights (fill in path to trained weights here)
    assert model_path != "", "Provide path to trained weights"
    print("Loading weights from ", model_path)
    model.load_weights(model_path, by_name=True)

    #overall_perfomance(model, dataset_val, inference_config)
    #fig, ax = plt.subplots(1, 1, figsize=(12, 10))
    #visualize.plot_precision_recall(AP, precisions, recalls, ax=ax)
    #fig.savefig('roc_curve')
    image_ids = np.random.choice(dataset_val.image_ids, 15)
    for i in image_ids:  # range(5):
    #for i in [267]:
        test_rand_image(model, dataset_val, inference_config, i)
    test_rand_image(model, dataset_val, inference_config, 267)


def test_rand_image(model, dataset_val, inference_config, image_id):
    #image_id = random.choice(dataset_val.image_ids)
    original_image, image_meta, gt_class_id, gt_bbox, gt_mask, gt_debl, gt_mult =\
        modellib.load_image_gt(dataset_val, inference_config,
                               image_id, use_mini_mask=False)
    print("mul_image", gt_mult.shape)
    #log("original_image", original_image)
    #log("image_meta", image_meta)
    #log("gt_class_id", gt_class_id)
    #log("gt_bbox", gt_bbox)
    #log("gt_mask", gt_mask)
    results = model.detect([original_image], verbose=1)
    r = results[0]
    if (gt_mask.shape[-1] == 0) or (r['masks'].shape[-1] == 0):
        print(image_id, " skipped")
        return
    print(image_id, r['scores'])
    #fig, axarr = plt.subplots(1, 2, figsize=(12, 10))
    #visualize.display_instances(original_image, gt_bbox, gt_mask, gt_class_id,
    #                            dataset_val.class_names, ax=axarr[0], limits=[20, 100])
    #plt.savefig('disp1')
    #visualize.display_instances(original_image, r['rois'], r['masks'],
    #                            r['class_ids'], dataset_val.class_names,
    #                            r['scores'], ax=axarr[1], limits=[20, 100])
    #fig.savefig('true_output_' + str(image_id))
    #fig, ax = plt.subplots(1, 1, figsize=(12, 10))
    # axarr[0].imshow(original_image.astype(np.uint8()), interpolation='none')
    #axarr[0].imshow(original_image, interpolation='none')
    #axarr[0].set_xlim([20, 100])
    #axarr[0].set_ylim([20, 100])
    #axarr[0].axis('off')
    rgb_image = display.img_to_rgb(np.transpose(original_image, axes=(2, 0, 1)))
    visualize.display_debl_output(rgb_image, r['masks'], r['debl'], gt_mult[:,:,0],
                                 r['class_ids'], dataset_val.class_names,
                                     limit=5)
    #visualize.display_differences(original_image, gt_bbox, gt_class_id,
    #                              gt_mask, r['rois'], r['class_ids'],
    #                              r['scores'], r['masks'],
    #                              dataset_val.class_names, ax=axarr[1],
    #                              limits=[20, 108], mask_alpha=0.1)
    #fig.savefig('debl_output_' + str(image_id))
    plt.savefig('debl_output_' + str(image_id))


def main():
    dataset_val = train.ShapesDataset()
    dataset_val.load_data(training=False)
    dataset_val.prepare()
    #config = train.InputConfig()
    #config.display()

    inference_config = InferenceConfig()
    # Validation dataset
    image_ids = np.random.choice(dataset_val.image_ids, 5)
    image_ids = np.append(image_ids, [267])
    #image_ids = np.append(image_ids, [699])
    #image_ids = [267]
    for image_id in image_ids:
        image = dataset_val.load_image(image_id)
        print("input image", image.shape, np.max(image), image.dtype)
        rgb_image = display.img_to_rgb(np.transpose(image, axes=(2, 0, 1)))
        mask, class_ids = dataset_val.load_mask(image_id)
        debl = dataset_val.load_debl_image(image_id)

        mult_image = dataset_val.load_mult_image(image_id)[:, :, 0] # load_mult_image loads 2 images for the 2 overlapping objects
        # visualize.display_sep_masks(image, mask, class_ids, dataset_val.class_names,
        #                            limit=2)
        original_image, image_meta, gt_class_id, gt_bbox, gt_mask, gt_debl, gt_mult =\
        modellib.load_image_gt(dataset_val, inference_config,
                               image_id, use_mini_mask=False)
        rgb_image = display.img_to_rgb(np.transpose(original_image, axes=(2, 0, 1)))
        print(image_id, gt_bbox.shape, gt_debl.shape)
        visualize.display_debl_input(rgb_image, gt_bbox, gt_debl, gt_mult[:,:,0],str(image_id))
        #visualize.display_debl_input(rgb_image, mask, debl, mult_image,
        #                             class_ids, dataset_val.class_names,
        #                             limit=6)
        #plt.savefig("input_debl_" +str(image_id))

    evaluate(dataset_val)


if __name__ == "__main__":
    main()