MASK-RCNN para encontrar telhados a partir de imagens de drones

Problemas

• existe uma diferença significativa entre as fotografias aéreas de inverno e de verão (um modelo treinado apenas em fotografias de verão é completamente incapaz de encontrar telhados no inverno);
• , ;
• , ( ), ( ) , ;
• , , ( ). ;
• (, ) .

• não tivemos a tarefa de realizar inferência por um tempo limitado (por exemplo, diretamente no momento do voo), o que resolveu imediatamente todos os possíveis problemas com o desempenho;
• na entrada para processamento, imediatamente recebemos imagens de alta qualidade e alta resolução (usando lentes com uma distância focal de 21 mm a uma altura de 250 m, que é de 5 cm / px) de nosso cliente, a empresa Shakhty, poderia usar seus conhecimentos na localização geográfica de objetos em mapas e eles também tiveram a oportunidade de estabelecer um conjunto específico de requisitos para futuros voos de UAV, o que reduziu bastante a probabilidade de peças muito exclusivas que não estavam no conjunto de treinamento;

A primeira solução para o problema, traçado usando a caixa Limite 

• O Anaconda é um sistema conveniente de gerenciamento de pacotes para Python e R.
• O Tensorflow é uma biblioteca de software de aprendizado de máquina de código aberto desenvolvida pelo Google.
• Keras é um complemento para os frameworks Deeplearning4j, TensorFlow e Theano.
• O OpenCV é uma biblioteca de algoritmos para visão computacional, processamento de imagens e algoritmos numéricos de código aberto de uso geral.
• Flask é uma estrutura para criar aplicativos da Web na linguagem de programação Python.

Preparação de Azulejos

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)
...

Marcação de dados de treinamento 

• / . :

• , , :

...

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)

• há muitos sobrevôos em que há um grande número de telhados não retangulares, por isso há muito trabalho manual para refinar a área,
• às vezes encontrado em casa com orientações diferentes no mesmo bloco,
• Às vezes, existem muitas linhas falsas nos ladrilhos, o que acaba levando a uma curva errada. Se parece com isso:

A solução final baseada em Mask-RCNN

• padrão para todas as redes neurais convolucionais, a alocação de recursos na imagem, como linhas, curvas, limites contrastantes e outros;
• A Region Proposal Network (RPN) varre pequenos fragmentos da imagem, chamados âncoras (âncoras) e determina se essa âncora contém sinais específicos para a classe de destino (no nosso caso, o telhado);
• Classificação da região de interesse e caixa delimitadora. Nesse estágio, a rede, com base nos resultados do estágio anterior, está tentando destacar grandes áreas retangulares na fotografia, presumivelmente contendo o objeto de destino;
• Máscaras de segmentação. Nesse estágio, a máscara do objeto desejado é obtida da área retangular obtida pela aplicação da caixa de limite.

Métricas usadas para avaliar a qualidade do modelo

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 - mostra quão bem o modelo localiza objetos (ou seja, impõe uma caixa de limite);
• val_mrcnn_mask_loss - mostra o quão bem o modelo segmenta objetos (ou seja, impõe uma máscara).

Treinamento e validação de modelos

Criando um serviço em segundo plano para reconhecimento

sudo vim my_srv.service

• [Unidade] - descreve a ordem e condição da partida (por exemplo, você pode dizer ao processo para aguardar o início de um determinado serviço e só então iniciá-lo você mesmo);
• [Serviço] - descreve parâmetros de inicialização;
• [Instalar] - descreve o comportamento do serviço ao adicioná-lo à inicialização.

[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

achados