MASK-RCNN pour trouver des toits à partir d'images de drones

Problèmes

• il existe une différence significative entre les photographies aériennes d'hiver et d'été (un modèle formé uniquement aux photographies d'été est totalement incapable de trouver des toits en hiver);
• , ;
• , ( ), ( ) , ;
• , , ( ). ;
• (, ) .

• nous n'avons eu aucune tâche pour effectuer l'inférence pendant un temps limité (par exemple, directement au moment du vol), ce qui a immédiatement résolu tous les problèmes de performances possibles;
• à l'entrée pour le traitement, nous avons immédiatement reçu des images haute résolution de haute qualité (en utilisant des objectifs avec une focale de 21 mm à une hauteur de 250 m, soit 5 cm / px) de notre client, la société Shakhty, pourrait utiliser leur expertise dans la géolocalisation des objets sur les cartes, et ils ont également eu l'occasion d'établir un ensemble spécifique d'exigences pour les futurs vols d'UAV, ce qui a finalement considérablement réduit la probabilité de carreaux très uniques qui n'étaient pas dans l'ensemble de formation;

La première solution au problème, l'AVC à l'aide de la boîte Boundary 

• Anaconda est un système de gestion de paquets pratique pour Python et R.
• Tensorflow est une bibliothèque de logiciels d'apprentissage automatique open source développée par Google.
• Keras est un module complémentaire pour les frameworks Deeplearning4j, TensorFlow et Theano.
• OpenCV est une bibliothèque d'algorithmes pour la vision par ordinateur, le traitement d'image et les algorithmes numériques open source à usage général.
• Flask est un framework pour créer des applications web dans le langage de programmation Python.

Préparation des carreaux

from pyproj import Proj, transform

class Converter:
    P3857 = Proj(init='epsg:3857')
    P4326 = Proj(init='epsg:4326')
...
    def from_3857_to_GPS(self, point):
        x, y = point
        return transform(self.P3857, self.P4326, x, y)
    def from_GPS_to_3857(self, point):
        x, y = point
        return transform(self.P4326, self.P3857, x, y)
...

Balisage des données de formation 

• / . :

• , , :

...

lines = cv2.HoughLinesP(edges, 1, np.pi/180, 50, minLineLength=minLineLength, maxLineGap=5)
if lines is not None:
    length = image.shape[0]
    angles = []
    for x1, y1, x2, y2 in lines[0]:
        angle = math.degrees(math.atan2(y2 — y1, x2 - x1))
        angles.append(angle)
    parts_angles.append(angles)
    median_angle = np.median(angles)
...

#     

for x in range(0, image.shape[0]-1, image.shape[0] // count_crops):
    for y in range(0, image.shape[1]-1, image.shape[1] // count_crops):
        get_line(image[x:x+image.shape[0]//count_crops, y:y+image.shape[1]//count_crops, :])
...

#      

np.median([a if a>0 else 90+a for a in np.array(parts_angles).flatten()])

h, w = image.shape[:2]
image_center = (w/2, h/2)

if size is None:
    radians = math.radians(angle)
    sin = math.sin(radians)
    cos = math.cos(radians)
    size = (int((h * abs(sin)) + (w * abs(cos))), int((h * abs(cos)) + (w * abs(sin))))
    rotation_matrix = cv2.getRotationMatrix2D(image_center, angle, 1)
    rotation_matrix[0, 2] += ((size[0] / 2) — image_center[0])
    rotation_matrix[1, 2] += ((size[1] / 2) — image_center[1])
else:
    rotation_matrix = cv2.getRotationMatrix2D(image_center, angle, 1)

cv2.warpAffine(image, rotation_matrix, size)

• il y a beaucoup de survols où il y a un grand nombre de toits non rectangulaires, à cause de cela il y a trop de travail manuel pour affiner la zone,
• parfois trouvé à la maison avec des orientations différentes sur la même tuile,
• parfois il y a beaucoup de fausses lignes sur les tuiles, ce qui conduit finalement à un mauvais virage. Cela ressemble à ceci:

La solution finale basée sur Mask-RCNN

• standard pour tous les réseaux de neurones convolutifs, l'allocation de caractéristiques dans l'image, telles que les lignes, les virages, les frontières contrastées et autres;
• Le réseau de propositions de région (RPN) scanne de petits fragments de l'image, appelés ancres (ancres) et détermine si cette ancre contient des signes spécifiques à la classe cible (dans notre cas, le toit);
• Classification des régions d'intérêt et cadre de délimitation. À ce stade, le réseau, sur la base des résultats de l'étape précédente, tente de mettre en évidence de grandes zones rectangulaires dans la photographie, contenant vraisemblablement l'objet cible;
• Masques de segmentation. A ce stade, le masque de l'objet souhaité est obtenu à partir de la zone rectangulaire obtenue en appliquant la boîte frontière.

Mesures utilisées pour évaluer la qualité du modèle

from shapely.geometry import Polygon

true_polygon = Polygon([(2, 2), (2, 6), (5, 6), (5, 2)])
predicted_polygon = Polygon([(3, 3), (3, 7), (6, 7), (6, 3)])
print(true_polygon.intersection(predicted_polygon).area / true_polygon.union(predicted_polygon).area)

>>> 0.3333333333333333

• val_mrcnn_bbox_loss - montre à quel point le modèle localise les objets (c.-à-d. impose une boîte frontière);
• val_mrcnn_mask_loss - montre à quel point le modèle segmente les objets (c'est-à-dire impose un masque).

Formation et validation des modèles

Création d'un service d'arrière-plan pour la reconnaissance

sudo vim my_srv.service

• [Unité] - décrit l'ordre et la condition du démarrage (par exemple, vous pouvez dire au processus d'attendre le démarrage d'un certain service et de le démarrer ensuite vous-même);
• [Service] - décrit les paramètres de démarrage;
• [Installer] - décrit le comportement du service lors de son ajout au démarrage.

[Unit]
Description=my_test_unit

[Service]
WorkingDirectory=/home/user/test_project
User=root
ExecStart=/home/user/test_project/venv/bin/python3 /home/user/test_project/script.py

[Install]
WantedBy=multi-user.target

sudo systemctl daemon-reload
sudo systemctl start my_srv.service

résultats