Automatic roads segmentation

Introduction
We understand that life is too short to annotate thousands of images manually. In this blog post we describe how to use the human-in-the-loop aproach for automatic image segmentation. We applied this approach to create a big and high-quality training dataset for person segmentation:
The dataset consists of 5711 images with 6884 high-quality annotated person instances
Annotation team consisted of two members and the whole process took only 4 days
This tutorial is a step by step guide to help you apply the human in the loop approach to your custom task. For example, we will consider road segmentation. But you can change the target classes and reproduce the results for your custom data.
Of course such approach cannot be applicable to all possible segmentation and detection tasks. But we believe that this method will cover 90% of common scenarios. For some "exotic" or "hard" cases we have a number of tricks and workarounds that will be discussed in our next tutorials.
We added this data to our Explore section so you can reproduce our experiment yourself.
Task description
One of our partners has a huge number of videos with road scenes for both country and city roads. They annotate a lof of objects and road is one of them. They collect tens of millions of images and all these images need to be annotated. Of course it is impossible to do so manually. Sometimes images from the neighboring frames look the same, sometimes images the are pretty diverse (i.e. various weather and lighting conditions). Here are a few examples:
So we are going to train a neural network that will help our annotation team with road segmentation.
Pipeline
We slightly simplified the real use case (for tutorial purposes). We took only one video file (~ 11k images). The frames (image) were taken every two meters. So this video file corresponds to ~20 kilometers of a real road.
High-level pipeline:
1.
We randomly selected 156 images from the video. These images will be used for testing. We put them into the roads_test project.
2.
We manually selected 10 images from the video. Of course all these images are not present in our test set. But they were chosen to cover the variety of test images as much as possible. These images will be annotated and then used for training. We put them into the roads_annotated project.
3.
We performed a DTL query to apply data augmentations to our 10 annotated images (project roads_annotated). Thus, we got a training set of 220 images. We named the resulting project train_01.
4.
We trained a neural network for roads segmentation on the train_01 project. We took UNetV2 architecture and init weights from VGG. You can choose any another neural network. We chose UNetV2 because it is fast to train and it is pretty accurate. As a result we got the nn_road_01 model.
5.
We apply the nn_road_01 model to the test images and put neural network predictions into the inf_01_roads_test project. Road on many images is presegmented really nice, but there are the cases when NN fails.
6.
We clone inf_01_roads_test project (just to save the original predictions) to the project inf_01_annotated, choose 5 images and correct the NN predictions manually. We tag corrected images with the corrected tag.
7.
We apply DTL to combine the new 5 annotated images (correction of the NN predictions) and the 10 annotated images (that were annotated manually from scratch), apply augmentations for them (like in step 3). Thus, we get a training set of 440 images. We name the resulting project as train_02.
8.
We take the nn_road_01 model and continue its training on the new project train_02. As a result we get the nn_road_02 model.
9.
We apply the nn_road_02 model to our test images and put the neural network predictions into inf_02_roads_test project. We compare these predictions with the previous ones and see that NN becomes smarter, presegmentation becomes better and that most images have ideal presegmentation.
All steps took us 45 minutes:
NN training time: 23 minutes. Time to ☕
Manual annotation of 15 images: 12 minutes.
Moving mouse cursor and pressing the necessary buttons inside Supervisely: 8 minutes.
The method described above is iterative. So if you cannot achieve the necessary performance, just make a few iterations. We recommend to make fast iterations: annotate a new relatively small portion of images, train a new model and test it on a big testset to monitor the progress in quality. After a few iterations you will get both: an accurate neural network and a big training dataset.
As we said in the beginning, current use case was simplified. But you can scale up it easily. Just take 50 videos or more and apply the described steps to all of them. Thus the resulting neural network will generalize better.
Steps 1-2. Initial data preparation.
We uploaded the test images to the roads_test project, and the images that we are going to annotate to the roads_annotated project. Project roads_test consists of 156 images, project roads_annotated consists of 10 images.
A few examples of annotated images:
A few examples of test images:
Step 3. First training set with DTL
So we have 10 annotated images. We have to augment our data before we start training. We apply a DTL query to create a training set of 220 images from 10 images.
Here is the raw DTL config:
1
[
2
  {
3
    "dst": "$sample",
4
    "src": [
5
      "roads_annotated/*"
6
    ],
7
    "action": "data",
8
    "settings": {
9
      "classes_mapping": "default"
10
    }
11
  },
12
  {
13
    "dst": "$fv",
14
    "src": [
15
      "$sample"
16
    ],
17
    "action": "flip",
18
    "settings": {
19
      "axis": "vertical"
20
    }
21
  },
22
  {
23
    "dst": "$data",
24
    "src": [
25
      "$fv",
26
      "$sample"
27
    ],
28
    "action": "dummy",
29
    "settings": {}
30
  },
31
  {
32
    "dst": "$data2",
33
    "src": [
34
      "$data"
35
    ],
36
    "action": "multiply",
37
    "settings": {
38
      "multiply": 10
39
    }
40
  },
41
  {
42
    "dst": "$data3",
43
    "src": [
44
      "$data2"
45
    ],
46
    "action": "crop",
47
    "settings": {
48
      "random_part": {
49
        "width": {
50
          "max_percent": 90,
51
          "min_percent": 70
52
        },
53
        "height": {
54
          "max_percent": 90,
55
          "min_percent": 70
56
        },
57
        "keep_aspect_ratio": false
58
      }
59
    }
60
  },
61
  {
62
    "dst": [
63
      "$totrain",
64
      "$toval"
65
    ],
66
    "src": [
67
      "$data3",
68
      "$data"
69
    ],
70
    "action": "if",
71
    "settings": {
72
      "condition": {
73
        "probability": 0.95
74
      }
75
    }
76
  },
77
  {
78
    "dst": "$train",
79
    "src": [
80
      "$totrain"
81
    ],
82
    "action": "tag",
83
    "settings": {
84
      "tag": "train",
85
      "action": "add"
86
    }
87
  },
88
  {
89
    "dst": "$val",
90
    "src": [
91
      "$toval"
92
    ],
93
    "action": "tag",
94
    "settings": {
95
      "tag": "val",
96
      "action": "add"
97
    }
98
  },
99
  {
100
    "dst": "$data_with_bg",
101
    "src": [
102
      "$train",
103
      "$val"
104
    ],
105
    "action": "background",
106
    "settings": {
107
      "class": "bg"
108
    }
109
  },
110
  {
111
    "dst": "train_01",
112
    "src": [
113
      "$data_with_bg"
114
    ],
115
    "action": "supervisely",
116
    "settings": {}
117
  }
118
]
Copied!
Explanation:
Here are a few examples of images after augmentations:
Step 4. Train the first NN
Basic step by step training guide is here. It is the same for all models inside Supervisely. Detailed information regarding training configs is here.
UNetV2 weihts were initialized from the corresponding model from the Models list (UNetV2 with VGG weigths that was pretrained on ImageNet).
The resulting model will be named nn_road_01. Project train_01 is used for training.
Training configuration:
1
{
2
  "lr": 0.001,
3
  "epochs": 20,
4
  "val_every": 1,
5
  "batch_size": {
6
    "val": 1,
7
    "train": 4
8
  },
9
  "input_size": {
10
    "width": 512,
11
    "height": 512
12
  },
13
  "gpu_devices": [
14
    0,
15
    1,
16
    2
17
  ],
18
  "data_workers": {
19
    "val": 0,
20
    "train": 3
21
  },
22
  "dataset_tags": {
23
    "val": "val",
24
    "train": "train"
25
  },
26
  "special_classes": {
27
    "neutral": "neutral",
28
    "background": "bg"
29
  },
30
  "weights_init_type": "transfer_learning"
31
}
Copied!
Training takes 8 minutes on three GPUs. Here is the loss chart during training:
If we set a lof of epochs on training, the chart becomes awkward. So we can set the range of epochs we want to show. Thus we can monitor the local changes of accuracy and loss. Here is an example:
Step 5. Apply the first NN to the test data
Basic step by step inference guide is here. It is the same for all models inside Supervisely. Detailed information regarding inference configs is here.
We apply the model nn_road_01 to the project roads_test. The resulting project with neural network predictions will be saved as inf_01_roads_test.
Here are the predictions. Most of the predictions look perfect, but there are some mistakes:
Step 6. Correct the NN predictions
Firstly we clone the project inf_01_roads_test to inf_01_annotated just to save the original predictions and then compare them with the future predictions. We choose 5 images and correct them. Also we assign the tag "corrected" to them. Here they are:
Step 7. Second training set with DTL
I think this is the most interesting part of this guide. We need to combine the first annotated images (10 images) with the new ones (5 images) and then apply augmentations we use in Step 3.
Here is the raw DTL query:
1
[
2
  {
3
    "dst": "$sample_inf",
4
    "src": [
5
      "inf_01_annotated/*"
6
    ],
7
    "action": "data",
8
    "settings": {
9
      "classes_mapping": {
10
        "__other__": "__ignore__",
11
        "road_unet": "road"
12
      }
13
    }
14
  },
15
  {
16
    "dst": [
17
      "$corrected",
18
      "$to_skip"
19
    ],
20
    "src": [
21
      "$sample_inf"
22
    ],
23
    "action": "if",
24
    "settings": {
25
      "condition": {
26
        "tags": [
27
          "corrected"
28
        ]
29
      }
30
    }
31
  },
32
  {
33
    "dst": "$inf_annotated",
34
    "src": [
35
      "$corrected"
36
    ],
37
    "action": "multiply",
38
    "settings": {
39
      "multiply": 2
40
    }
41
  },
42
  {
43
    "dst": "$inf_annotated_ds",
44
    "src": [
45
      "$inf_annotated"
46
    ],
47
    "action": "dataset",
48
    "settings": {
49
      "name": "iteration_01"
50
    }
51
  },
52
  {
53
    "dst": "$sample_bitmap_ds",
54
    "src": [
55
      "$sample_bitmap"
56
    ],
57
    "action": "dataset",
58
    "settings": {
59
      "name": "iteration_00"
60
    }
61
  },
62
  {
63
    "dst": "$annotated_data",
64
    "src": [
65
      "$inf_annotated_ds",
66
      "$sample_bitmap_ds"
67
    ],
68
    "action": "dummy",
69
    "settings": {}
70
  },
71
  {
72
    "dst": "$fv",
73
    "src": [
74
      "$annotated_data"
75
    ],
76
    "action": "flip",
77
    "settings": {
78
      "axis": "vertical"
79
    }
80
  },
81
  {
82
    "dst": "$sample",
83
    "src": [
84
      "roads_annotated/*"
85
    ],
86
    "action": "data",
87
    "settings": {
88
      "classes_mapping": {
89
        "road": "road_poly"
90
      }
91
    }
92
  },
93
  {
94
    "dst": "$sample_bitmap",
95
    "src": [
96
      "$sample"
97
    ],
98
    "action": "poly2bitmap",
99
    "settings": {
100
      "classes_mapping": {
101
        "road_poly": "road"
102
      }
103
    }
104
  },
105
  {
106
    "dst": "$data",
107
    "src": [
108
      "$fv",
109
      "$annotated_data"
110
    ],
111
    "action": "dummy",
112
    "settings": {}
113
  },
114
  {
115
    "dst": "$data2",
116
    "src": [
117
      "$data"
118
    ],
119
    "action": "multiply",
120
    "settings": {
121
      "multiply": 10
122
    }
123
  },
124
  {
125
    "dst": "$data3",
126
    "src": [
127
      "$data2"
128
    ],
129
    "action": "crop",
130
    "settings": {
131
      "random_part": {
132
        "width": {
133
          "max_percent": 90,
134
          "min_percent": 70
135
        },
136
        "height": {
137
          "max_percent": 90,
138
          "min_percent": 70
139
        },
140
        "keep_aspect_ratio": false
141
      }
142
    }
143
  },
144
  {
145
    "dst": [
146
      "$totrain",
147
      "$toval"
148
    ],
149
    "src": [
150
      "$data3",
151
      "$data"
152
    ],
153
    "action": "if",
154
    "settings": {
155
      "condition": {
156
        "probability": 0.95
157
      }
158
    }
159
  },
160
  {
161
    "dst": "$train",
162
    "src": [
163
      "$totrain"
164
    ],
165
    "action": "tag",
166
    "settings": {
167
      "tag": "train",
168
      "action": "add"
169
    }
170
  },
171
  {
172
    "dst": "$val",
173
    "src": [
174
      "$toval"
175
    ],
176
    "action": "tag",
177
    "settings": {
178
      "tag": "val",
179
      "action": "add"
180
    }
181
  },
182
  {
183
    "dst": "$data_with_bg",
184
    "src": [
185
      "$train",
186
      "$val"
187
    ],
188
    "action": "background",
189
    "settings": {
190
      "class": "bg"
191
    }
192
  },
193
  {
194
    "dst": "train_02",
195
    "src": [
196
      "$data_with_bg"
197
    ],
198
    "action": "supervisely",
199
    "settings": {}
200
  }
201
]
Copied!
Explanation:
As the result we got the project "train_02" with 440 images.
Step 8. Train the second NN
We take the nn_road_01 model and continue its training on the new project train_02. As a result we get the nn_road_02 model.
Here is the training config:
1
{
2
  "lr": 0.001,
3
  "epochs": 10,
4
  "val_every": 1,
5
  "batch_size": {
6
    "val": 1,
7
    "train": 4
8
  },
9
  "input_size": {
10
    "width": 512,
11
    "height": 512
12
  },
13
  "gpu_devices": [
14
    0,
15
    1,
16
    2
17
  ],
18
  "data_workers": {
19
    "val": 0,
20
    "train": 3
21
  },
22
  "dataset_tags": {
23
    "val": "val",
24
    "train": "train"
25
  },
26
  "special_classes": {
27
    "neutral": "neutral",
28
    "background": "bg"
29
  },
30
  "weights_init_type": "continue_training"
31
}
Copied!
Here are the loss and accuracy. Model becomes slightly better.
Step 9. Apply the second NN and compare results
We apply the nn_road_02 model to the roads_test project and save the predictions to inf_02_roads_test. Let's compare the predictions (project inf_01_roads_test and project inf_02_roads_test). New model has to be "smarter" then the previous one. Here we will show only the images, where model predictions became better. We revised all images and could not find any examples when it became worse.
If after the next iteration model predictions become worse, there is a huge chance that NN is overfitted. Try to restore a model from an earlier checkpoint. Read more info here.
Before
After
Before
After
Before
After
Conclusion
As you can see, with Supervisely and the human in the loop approach we can iterate until we get the necessary performance. It saves a lot of time of our annotation team. We've had experience with different segmentation tasks and in most cases this approach works. Of course there are more complicated scenarios (i.e. if we want to segment curbs, poles or other tricky objects, or our images are too wide). In our next tutorials we will give you a few workarounds for such examples.
Fast person detection
NNs and irregular image size
Last modified 1yr ago
Copy link
Contents
Introduction
Task description
Pipeline
Steps 1-2. Initial data preparation.
Step 3. First training set with DTL
Step 4. Train the first NN
Step 5. Apply the first NN to the test data
Step 6. Correct the NN predictions
Step 7. Second training set with DTL
Step 8. Train the second NN
Step 9. Apply the second NN and compare results
Conclusion