Smart Tool

Introduction
One of the best properties of Smart tool is that it can be tuned to your particular tasks.
If
you need an easier annotation of concrete classes
you work with objects of unusual shape or appearance
you just want to make Smart tool even smarter
You can achieve it by training Smart tool.
The tool is a neural network model and in Supervisely it may be trained like all the other models. This tutorial will show you how to train Smart tool to obtain a simple class-agnostic model which is smart enough.
Data preparation
Datasets
To get a class-agnostic model it's needed to be trained with a large amount of objects and parts of objects from different classes. We will use the following datasets as a source:
​Pascal VOC​
​Mapillary​
To achieve even more class ignorance one may include other datasets with different classes or even generate some artifical datasets.
Training samples
Our goal is to construct training samples with the following figures:
Target object or area to recognize:
We'll name it as obj class and represent it as a bitmap
Each training sample must contain one target object
Positive and negative points, which are imitating human feedback during annotation:
pos and neg classes correspondingly, with point type
TODO: add screenshot of some sample with obj, pos & neg
We want the model to "understand" different objects, edges and shapes. It shoul perform reasonable segmentation of a dominant object on the input image. However, the model must be obedient and correct the segmentation based on user feedback, i.e. positive and negative zones.
Pascal VOC
To generate training samples from Pascal VOC use the config below.
The following actions will be performed:
1.Crop each source object (excluding the tiny ones) with large padding. Note that the object may be placed not in the center of the result image due to image borders.
2.Mark samples randomly with train and val tags.
3.Get some number of random crops from each obtained sample (maybe flipped). This is performed because we don't really want to get many samples with clearly distinguishable dominating object. Instead of this we generate "hard" samples on which target objects are shifted randomly and are placed side-by-side with other objects.
4.Exclude samples where target objects are small or missing. Resize images to the required size (model input size)
5.Generate positive and negative points randomly for each sample. Positive points will be placed on target obj, and negative ones on the rest of sample image.
1
[
2
  {
3
    "src": [
4
      "PascalVOC/*"
5
    ],
6
    "dst": "$sample-pascal",
7
    "action": "data",
8
    "settings": {
9
      "classes_mapping": {
10
        "neutral": "unused",
11
        "__other__": "obj"
12
      }
13
    }
14
  },
15
  {
16
    "src": [
17
      "$sample-pascal"
18
    ],
19
    "dst": "$100",
20
    "action": "objects_filter",
21
    "settings": {
22
      "filter_by": {
23
        "polygon_sizes": {
24
          "filtering_classes": [
25
            "obj"
26
          ],
27
          "comparator": "less",
28
          "area_size": {
29
            "percent": 1
30
          },
31
          "action": "delete"
32
        }
33
      }
34
    }
35
  },
36
  {
37
    "src": [
38
      "$100"
39
    ],
40
    "dst": "$101",
41
    "action": "instances_crop",
42
    "settings": {
43
      "classes": [
44
        "obj"
45
      ],
46
      "pad": {
47
        "sides": {
48
          "left": "200%",
49
          "right": "200%",
50
          "top": "200%",
51
          "bottom": "200%"
52
        }
53
      }
54
    }
55
  },
56
  {
57
    "src": [
58
      "$101"
59
    ],
60
    "dst": [
61
      "$102-val",
62
      "$102-train"
63
    ],
64
    "action": "if",
65
    "settings": {
66
      "condition": {
67
        "probability": 0.05
68
      }
69
    }
70
  },
71
  {
72
    "src": [
73
      "$102-val"
74
    ],
75
    "dst": "$103-val",
76
    "action": "tag",
77
    "settings": {
78
      "tag": "val",
79
      "action": "add"
80
    }
81
  },
82
  {
83
    "src": [
84
      "$102-train"
85
    ],
86
    "dst": "$103-train",
87
    "action": "tag",
88
    "settings": {
89
      "tag": "train",
90
      "action": "add"
91
    }
92
  },
93
  {
94
    "src": [
95
      "$103-val",
96
      "$103-train"
97
    ],
98
    "dst": "$104",
99
    "action": "flip",
100
    "settings": {
101
      "axis": "vertical"
102
    }
103
  },
104
  {
105
    "src": [
106
      "$103-val",
107
      "$103-train",
108
      "$104"
109
    ],
110
    "dst": "$105",
111
    "action": "multiply",
112
    "settings": {
113
      "multiply": 3
114
    }
115
  },
116
  {
117
    "src": [
118
      "$105"
119
    ],
120
    "dst": "$106",
121
    "action": "crop",
122
    "settings": {
123
      "random_part": {
124
        "height": {
125
          "min_percent": 15,
126
          "max_percent": 95
127
        },
128
        "width": {
129
          "min_percent": 15,
130
          "max_percent": 95
131
        }
132
      }
133
    }
134
  },
135
  {
136
    "src": [
137
      "$106"
138
    ],
139
    "dst": [
140
      "$107",
141
      "$107-unused"
142
    ],
143
    "action": "if",
144
    "settings": {
145
      "condition": {
146
        "min_height": 50
147
      }
148
    }
149
  },
150
  {
151
    "src": [
152
      "$107"
153
    ],
154
    "dst": [
155
      "$108",
156
      "$108-unused"
157
    ],
158
    "action": "if",
159
    "settings": {
160
      "condition": {
161
        "min_width": 50
162
      }
163
    }
164
  },
165
  {
166
    "src": [
167
      "$108"
168
    ],
169
    "dst": "$109",
170
    "action": "resize",
171
    "settings": {
172
      "width": 256,
173
      "height": 256,
174
      "aspect_ratio": {
175
        "keep": false
176
      }
177
    }
178
  },
179
  {
180
    "src": [
181
      "$109"
182
    ],
183
    "dst": "$110",
184
    "action": "objects_filter",
185
    "settings": {
186
      "filter_by": {
187
        "polygon_sizes": {
188
          "filtering_classes": [
189
            "obj"
190
          ],
191
          "comparator": "less",
192
          "area_size": {
193
            "percent": 15
194
          },
195
          "action": "delete"
196
        }
197
      }
198
    }
199
  },
200
  {
201
    "src": [
202
      "$110"
203
    ],
204
    "dst": [
205
      "$111",
206
      "$111-unused"
207
    ],
208
    "action": "if",
209
    "settings": {
210
      "condition": {
211
        "min_objects_count": 1
212
      }
213
    }
214
  },
215
  {
216
    "src": [
217
      "$111"
218
    ],
219
    "dst": "$112",
220
    "action": "generate_hints",
221
    "settings": {
222
      "class": "obj",
223
      "positive_class": "pos",
224
      "negative_class": "neg",
225
      "min_points_number": 1
226
    }
227
  },
228
  {
229
    "src": [
230
      "$112"
231
    ],
232
    "dst": "smtool_dataset",
233
    "action": "supervisely",
234
    "settings": {}
235
  }
236
]
Copied!
Mapillary
To generate training samples from Mapillary use the config below.
The data transformation acts like one for Pascal VOC with two distinctions:
1.Not all source classes are used. Some classes in Mapillary (e.g. Terrain) represent "image-level" segmentation figures, and other may be too complicated for our training. The mapping is defined in Data layer.
2.Heavy class imbalance should be eliminated, otherwise the model will be trained mostly on images of cars and traffic signs. Separate "branch" in DTL config is needed to crop frequent objects and to drop the most part of them at random.
1
[
2
  {
3
    "src": [
4
      "Mapillary/*"
5
    ],
6
    "dst": "$sample-mapill",
7
    "action": "data",
8
    "settings": {
9
      "classes_mapping": {
10
        "Trailer": "obj",
11
        "Guard Rail": "obj",
12
        "Bench": "obj",
13
        "Trash Can": "obj",
14
        "Fire Hydrant": "obj",
15
        "Junction Box": "obj",
16
        "On Rails": "obj",
17
        "Bike Rack": "obj",
18
        "Ground Animal": "obj",
19
        "Phone Booth": "obj",
20
        "Bus": "obj",
21
        "Bicyclist": "obj",
22
        "Mailbox": "obj",
23
        "Manhole": "obj",
24
        "Traffic Sign (Back)": "obj_Freq",
25
        "Banner": "obj",
26
        "Other Vehicle": "obj",
27
        "Other Rider": "obj",
28
        "Motorcyclist": "obj",
29
        "Street Light": "obj",
30
        "Catch Basin": "obj",
31
        "Motorcycle": "obj",
32
        "Person": "obj",
33
        "Traffic Sign (Front)": "obj_Freq",
34
        "Car": "obj_Freq",
35
        "Caravan": "obj",
36
        "Billboard": "obj_Freq",
37
        "Truck": "obj",
38
        "Boat": "obj",
39
        "Wheeled Slow": "obj",
40
        "__other__": "unused"
41
      }
42
    }
43
  },
44
  {
45
    "src": [
46
      "$sample-mapill"
47
    ],
48
    "dst": "$100",
49
    "action": "objects_filter",
50
    "settings": {
51
      "filter_by": {
52
        "polygon_sizes": {
53
          "filtering_classes": [
54
            "obj",
55
            "obj_Car"
56
          ],
57
          "comparator": "less",
58
          "area_size": {
59
            "percent": 0.1
60
          },
61
          "action": "delete"
62
        }
63
      }
64
    }
65
  },
66
  {
67
    "src": [
68
      "$100"
69
    ],
70
    "dst": "$101-obj",
71
    "action": "instances_crop",
72
    "settings": {
73
      "classes": [
74
        "obj"
75
      ],
76
      "pad": {
77
        "sides": {
78
          "left": "200%",
79
          "right": "200%",
80
          "top": "200%",
81
          "bottom": "200%"
82
        }
83
      }
84
    }
85
  },
86
  {
87
    "src": [
88
      "$100"
89
    ],
90
    "dst": "$101-obj_Freq",
91
    "action": "instances_crop",
92
    "settings": {
93
      "classes": [
94
        "obj_Freq"
95
      ],
96
      "pad": {
97
        "sides": {
98
          "left": "200%",
99
          "right": "200%",
100
          "top": "200%",
101
          "bottom": "200%"
102
        }
103
      }
104
    }
105
  },
106
  {
107
    "src": [
108
      "$101-obj_Freq"
109
    ],
110
    "dst": [
111
      "$101-obj_Freq-selected",
112
      "$102-obj_Freq-unused"
113
    ],
114
    "action": "if",
115
    "settings": {
116
      "condition": {
117
        "probability": 0.1
118
      }
119
    }
120
  },
121
  {
122
    "src": [
123
      "$101-obj_Freq-selected"
124
    ],
125
    "dst": "$101-obj_Freq-renamed",
126
    "action": "rename",
127
    "settings": {
128
      "classes_mapping": {
129
        "obj_Freq": "obj"
130
      }
131
    }
132
  },
133
  {
134
    "src": [
135
      "$101-obj",
136
      "$101-obj_Freq-renamed"
137
    ],
138
    "dst": [
139
      "$102-val",
140
      "$102-train"
141
    ],
142
    "action": "if",
143
    "settings": {
144
      "condition": {
145
        "probability": 0.05
146
      }
147
    }
148
  },
149
  {
150
    "src": [
151
      "$102-val"
152
    ],
153
    "dst": "$103-val",
154
    "action": "tag",
155
    "settings": {
156
      "tag": "val",
157
      "action": "add"
158
    }
159
  },
160
  {
161
    "src": [
162
      "$102-train"
163
    ],
164
    "dst": "$103-train",
165
    "action": "tag",
166
    "settings": {
167
      "tag": "train",
168
      "action": "add"
169
    }
170
  },
171
  {
172
    "src": [
173
      "$103-val",
174
      "$103-train"
175
    ],
176
    "dst": "$104",
177
    "action": "flip",
178
    "settings": {
179
      "axis": "vertical"
180
    }
181
  },
182
  {
183
    "src": [
184
      "$103-val",
185
      "$103-train",
186
      "$104"
187
    ],
188
    "dst": "$105",
189
    "action": "multiply",
190
    "settings": {
191
      "multiply": 3
192
    }
193
  },
194
  {
195
    "src": [
196
      "$105"
197
    ],
198
    "dst": "$106",
199
    "action": "crop",
200
    "settings": {
201
      "random_part": {
202
        "height": {
203
          "min_percent": 15,
204
          "max_percent": 95
205
        },
206
        "width": {
207
          "min_percent": 15,
208
          "max_percent": 95
209
        }
210
      }
211
    }
212
  },
213
  {
214
    "src": [
215
      "$106"
216
    ],
217
    "dst": [
218
      "$107",
219
      "$107-unused"
220
    ],
221
    "action": "if",
222
    "settings": {
223
      "condition": {
224
        "min_height": 50
225
      }
226
    }
227
  },
228
  {
229
    "src": [
230
      "$107"
231
    ],
232
    "dst": [
233
      "$108",
234
      "$108-unused"
235
    ],
236
    "action": "if",
237
    "settings": {
238
      "condition": {
239
        "min_width": 50
240
      }
241
    }
242
  },
243
  {
244
    "src": [
245
      "$108"
246
    ],
247
    "dst": "$109",
248
    "action": "resize",
249
    "settings": {
250
      "width": 256,
251
      "height": 256,
252
      "aspect_ratio": {
253
        "keep": false
254
      }
255
    }
256
  },
257
  {
258
    "src": [
259
      "$109"
260
    ],
261
    "dst": "$110",
262
    "action": "objects_filter",
263
    "settings": {
264
      "filter_by": {
265
        "polygon_sizes": {
266
          "filtering_classes": [
267
            "obj"
268
          ],
269
          "comparator": "less",
270
          "area_size": {
271
            "percent": 15
272
          },
273
          "action": "delete"
274
        }
275
      }
276
    }
277
  },
278
  {
279
    "src": [
280
      "$110"
281
    ],
282
    "dst": [
283
      "$111",
284
      "$111-unused"
285
    ],
286
    "action": "if",
287
    "settings": {
288
      "condition": {
289
        "min_objects_count": 1
290
      }
291
    }
292
  },
293
  {
294
    "src": [
295
      "$111"
296
    ],
297
    "dst": "$112",
298
    "action": "generate_hints",
299
    "settings": {
300
      "class": "obj",
301
      "positive_class": "pos",
302
      "negative_class": "neg",
303
      "min_points_number": 1
304
    }
305
  },
306
  {
307
    "src": [
308
      "$112"
309
    ],
310
    "dst": "smtool_dataset",
311
    "action": "supervisely",
312
    "settings": {}
313
  }
314
]
Copied!
Training
Train
With the prepared data we may train Smart tool like any other model.
Consider using a pre-trained model to continue training. One may be found in Model Zoo.
Here is an example of the training config:
1
{
2
  "input_size": {
3
    "width": 256,
4
    "height": 256
5
  },
6
  "batch_size": {
7
    "train": 16,
8
    "val": 16
9
  },
10
  "data_workers": {
11
    "train": 3,
12
    "val": 0
13
  },
14
  "epochs": 30,
15
  "val_every": 1,
16
  "lr": 0.1,
17
  "momentum": 0.9,
18
  "lr_decreasing": {
19
      "patience": 10,
20
      "lr_divisor": 5
21
  },
22
  "loss_weights": {
23
    "main_class": 1,
24
    "points": 0.5
25
  },
26
  "special_classes": {
27
    "foreground": "obj",
28
    "background": "bg",
29
    "neutral": "neutral",
30
    "pos": "pos",
31
    "neg": "neg"
32
  },
33
  "weights_init_type": "continue_training",
34
  "gpu_devices": [
35
    0,
36
    1,
37
    2,
38
    3
39
  ]
40
}
Copied!
Note that there are special_classes for SmartTool:
foreground means name of "main" class in the input project (model performs binary segmentation, object-vs-background)
pos and neg must be points
Test
Inference can be run on some existing project/dataset like for any other model. Provide a project with points of corresponding "pos" and "neg" classes to look at the model reaction.
Here is an example of inference config:
1
{
2
  "model": {
3
    "gpu_device": 0
4
  },
5
  "mode": {
6
    "name": "full_image",
7
    "model_classes": {
8
      "save_classes": [
9
        "obj"
10
      ],
11
      "add_suffix": "_smtool"
12
    }
13
  }
14
}
Copied!
Faster R-CNN
Next - Customization
Plugins
Last modified 2yr ago
Copy link
Contents