Введение

Для проведения проверки мне необходимо было установить адреса нескольких сотен объектов недвижимости. Проблема в том, что адреса были написаны в разных частях документов, документы имели различные форматы, и сам адрес также мог быть написан разнообразными способами.  

Да, существует возможность использовать для данной задачи различные библиотеки и сервисы, но источники данных с информацией об этих объектах должны быть упорядочены и однородны. Можно ли используя минимум ресурсов решать подобные задачи? Можно! Рассмотрим решение на основе Python 3, Pandas и нескольких библиотек для конвертации файлов в датафреймы.

Конечно, удобнее работать с данными, представленными в виде упорядоченных списков адресов, геотэгов и пр. (изображение 1). В нашем случае в структуре адресов:

• использованы различные разделители (точки, запятые, прочие разделительные знаки)

• в строках с адресами присутствовала «мусорная» информация, не относящаяся к адресу

• адрес может был представлен как в полном формате (страна, район/область, населённый пункт, улица, строение, помещение), так и в любом сокращённом (изображение 2)
  

Относительно небольшого набора документов ситуация не представляется проблемной, все нужные данные можно собрать вручную, унифицировать разделители и обрезать всё лишнее. Но что если таких файлов много?

Извлечение информации

Итак, у нас в наличии есть набор файлов, в которых поля с адресами, расположены в различных частях документа. При этом, столбцы неоднородны; данные по адресу могут содержаться как в одном столбце, так и в нескольких; в том числе могут отличаться заголовки столбцов; плюс к каждому из них применяются все свойства проблемной структуры, описанные выше. Все эти нюансы усложняют унификацию процесса сбора информации, но мы постараемся собрать данные воедино.

Следующим шагом с помощью обработчиков для различных видов документов (pdf, excel и word) соберём данные в датафреймы. В случае с файлами Excel, можно воспользоваться встроенными функциями библиотеки pandas (ExcelFile, read_excel). Word - файлы так же не доставят особых проблем (функция Document в библиотеке docx). И в первом, и во втором случае понадобятся небольшие «косметические правки» (поля с датами, спецсимволы и т.п.) и в целом, данные будут готовы для обработки. Наибольшего внимания требуют файлы формата PDF. Из-за своей структуры PDF файлы не позволяют перенести данные напрямую, в следствии чего, приходится обрабатывать документ с учётом его разметки, внутренних изображений, блоков и т.п.

import pandas as pd
import tabula
import fitz
import ast

def sort_blocks(blocks):
    # упорядочиваем блоки, т.к. их порядок может быть нарушен (особенности разбора pdf файлов)
    sorteded_blocks = []
    for b in blocks:
        x0 = str(int(b["bbox"][0] + 0.99999)).rjust(4, "0")
        y0 = str(int(b["bbox"][1] + 0.99999)).rjust(4, "0")
        sort_key = y0 + x0
        sorteded_blocks.append([sort_key, b])
    return [b[1] for b in sorted(sorteded_blocks)]

def sort_lines(lines):
    # аналогично блокам поступаем с лайнами
    sorted_lines = []
    for l in lines:
        y0 = str(int(l["bbox"][1] + 0.99999)).rjust(4, "0")
        sorted_lines.append([y0, l])
    return [l[1] for l in sorted(sorted_lines)]

def sort_spans(spans):
    # аналогично блокам поступаем со спэнами
    sorted_spans = []
    for s in spans:
        x0 = str(int(s["bbox"][0] + 0.99999)).rjust(4, "0")
        sorted_spans.append([x0, s])
    return [s[1] for s in sorted(sorted_spans)]

def get_data_from_pdf_with_fitz(file):
    fitz_document = fitz.Document(file)
    fitz_document_pages = fitz_document.pageCount
    pdf_data = ""
    for page_number in range(fitz_document_pages):
        # разбиваем pdf файл на подэлементы и далее каждый на составные части
        page_data = ""
        page = fitz_document.loadPage(page_number)
        page_text = page.getText("json")
        # страница делится на блоки
        page_dict = ast.literal_eval(page_text)
        page_blocks = sort_blocks(page_dict["blocks"])
        for block in page_blocks:
            if "image" not in block.keys():
                # блоки на лайны
                page_lines = sort_lines(block["lines"])
                for line in page_lines:
                    # лайны на спэны
                    page_spans = sort_spans(line["spans"])
                    for span in page_spans:
                        if page_data.endswith(" ") or span["text"].startswith(" "):
                            page_data += span["text"]
                        else:
                            page_data += " " + span["text"]
                    page_data += "\n"
        pdf_data += page_data + "\n "
    return pdf_data

def get_data_from_pdf(file):
    pdf_data = get_data_from_pdf_with_fitz(file)
    pdf_data = re.sub(r"[\«\»\"]", " ", pdf_data)
    pdf_data = re.sub(r"\s+", " ", pdf_data)
    try:
        dataframe_container = []    
        dataframes = tabula.read_pdf(pdf_data, lattice=True, stream=True, pages='all', pandas_options={"header": None})
        for n, dataframe in enumerate(dataframes):
            for k in range(dataframe.shape[0]):
                dataframe_container.append(dataframes[n].values[k])
        dataframe = pd.DataFrame(df_container)
        return dataframe
    except Exception as e:
        return e

Альтернативный вариант – передать обработку подобных файлов стороннему ПО, например, ABBYY Fine Reader.  В целом, результат будет примерно одинаковый и в большинстве случаев удовлетворительный.

Далее необходимо определить, в какой части документа, а точнее в каких столбцах датафреймов находятся адреса. Если структура документа сохраняется и данные остаются без смещений (т.е. все адреса для каждой строчки остаются в искомых столбцах), можно выделять необходимые столбцы отталкиваясь от их имён (тогда предварительно нужно вручную, либо с помощью какого-то алгоритма собрать список наименований подобных столбцов), в противном случае нужно детектировать адреса используя маску поиска, а затем на основе первой найденной ячейки с адресом выделять и весь столбец, полагая, что в нём так же содержатся адреса.

Import re

address_subwords = [
                    "Адрес", "АО", "аал", "Аобл\.", "аллея", "аул", "б-р", "волость", "въезд", "высел\.", "г\.",
                    "городок", "дп\.", "д\.", "дор\.", "ж\/д", "жт\.", "заезд", "заимка", "казарма",
                    "кв-л\.", "км\.", "кольцо", "край", "кп\.", "линия", "мкр\.", "наб\.", "нп\.",
                    "обл\.", "остров", "окр\.", "парк", "переезд", "пер\.", "п\/р", "платф\.", "пл-ка",
                    "пл\.", "полустанок", "пгт\.", "п\/ст\.", "п\.ст\.", "п\.", "починок", "п\/о",
                    "проезд", "промзона", "просек", "проселок", "пр-кт", "проулок", "рп\.", "рзд\.",
                    "р-н", "Респ\.", "сал", "с\.", "с\/а\.", "с\/о\.", "с\/с\.", "сквер", "сл\.",
                    "ст-ца", "ст\.", "стр\.", "тер\.", "тракт", "туп\.", "ул\.", "у\.", "уч-к", "х\.", "ш\."
]
# data - строка для обработки
address = [subword for subword in address_subwords if re.search(r'^%s|\s%s' % (subword, subword), str(data).strip(), flags=re.I | re.M)]

Впрочем, не редко конвертация и/или обработка приводит к ситуации, когда данные смещаются, изменяются. На рисунке (изображение 3) приведен пример документа со смещёнными данными. Данный документ был изначально представлен в виде отсканированного изображения (PDF файл). С помощью программы ABBYY FineReader он был конвертирован в формат excel, но необходимые столбцы с данными были деформированы. В данной ситуации будет недостаточно объединить несколько ключевых столбцов, т.к. заранее неизвестно, что это будут за столбцы, необходимо объединять все ячейки одной строки полностью. Это в свою очередь приведёт к ещё большему загрязнению адреса. Тем не менее на данном этапе у нас в наличии будут списки адресов, которые можно начать обрабатывать.

Обработка информации

Первым шагом для нормализации структуры адреса будет приведение текста к единому стилю. В тексте адреса могут как присутствовать разделители, так и отсутствовать, поэтому базовым вариантом будут считаться адреса без разделителей, очистим от них строку.

Далее начиная от глобальных структур (страна, район, область) будем производить поиск, по ключевым словам, с помощью регулярных выражений, до локальных структур (улица, строение, помещение).

Если ключевые слова не были найдены, значит адрес записан в таком формате, что его невозможно будет отделить от другого текста («мусора»). Тогда мы будем ориентироваться на наличие чисел в строке, означающих строение/помещение, но подобный ход может привести к отбору ненужной информации. Если ключевые слова были найдены, то производится попытка найти ключевые слова рангом ниже (убывание индекса структуры) далее в строке с отсеканием текста из левой части. При этом если следующее ключевое слово не было найдено, но при этом до числового значения (строения/помещения) были слова, проверяется в каком формате они были написаны, т.к. часть адреса, вероятнее всего, будет указана с большой буквы.

import re

def get_address(address):
    # address - строка, в которой предположительно находится адрес
    address_parts = []
    address_index = -1
    address_level_n = -1
    address_levels_name = ['subject', 'sub_subject', 'settlement', 'street', 'house']
    address_levels = [
        ["респ\.","республика","край","область","обл\.","г\.ф\.з\.","а\.окр\."],
        ["пос\.","поселение","р-н","район","с\/с","сельсовет"],
        ["г\.","город","пгт\.","рп\.","кп\.","гп\.","п\.","поселок","аал","арбан","аул","в-ки","выселки","г-к","заимка","з-ка","починок","п-к","киш\.","кишлак","п\.ст\.","ж\/д","м-ко","местечко","деревня","с\.","село","сл\.","ст\.","станция","ст-ца","станица","у\.","улус","х\.","хутор","рзд\.","разъезд","зим\.","зимовье","д\."],
        ["ал\.","аллея","б-р","бульвар","взв\.","взд\.","въезд","дор\.","дорога","ззд\.","заезд","километр","к-цо","кольцо","лн\.","линия","мгстр\.","магистраль","наб\.","набережная","пер-д","переезд","пер\.","переулок","пл-ка","площадка","пл\.","площадь","пр-кт\.","проспект","проул\.","проулок","рзд\.","разъезд","ряд","с-р","сквер","с-к","спуск","сзд\.","съезд","тракт","туп\.","тупик","ул\.","улица","ш\.","шоссе"],
        ["влд\.","владение","г-ж","гараж","д\.","дом","двлд\.","домовладение","зд\.","здание","з\/у","участок","кв\.","квартира","ком\.","комната","подв\.","подвал","кот\.","котельная","п-б","погреб","к\.","корпус","офис","пав\.","павильон","помещ\.","помещение","раб\.уч\.","скл\.","склад","соор\.","сооружение","стр\.","строение","торг\.зал\.","цех"]
    ]
    # пытаемся разбить строку на части используя спец-слова и сокращения
    # начинаем с верхнего уровня субъектов и спускаемся ниже, если разбивка не получается
    for i, level in enumerate(address_levels):
        for subword in level:
            address_split = re.split(r'%s' % subword, address, 1, flags=re.I | re.M)
            if len(address_split) > 1:
                clean_subword = re.sub(r'[^\w\.]', '', subword)
                # учитывая формат именования верхних уровней, ищем в строке наименование субъекта до ключевого слова
                # в противном случае отсекаем часть строки до ключевого слова
                if len(address_split[0]) > 0 and i < 2:
                    address_part_to_append = re.findall(r'[А-Я][^А-Я\d\s]+', address_split[0], flags=re.M)
                    if len(address_part_to_append) > 0:
                        address_parts.append(address_part_to_append[-1].strip() + ' ' + clean_subword)
                    else:
                        address_split[1] = clean_subword + ' ' + address_split[1].strip()
                else:
                    address_split[1] = clean_subword + ' ' + address_split[1].strip()
                address_level_n = i
                break
        if address_level_n > -1:
            break
    # в зависимости от разбивки, добавляем предполагаем части адреса к имеющимся, если они имеются
    if len(address_split) > 1:
        address_parts.extend(address_split[1].split(','))
    else:
        address_parts.extend(address_split[0].split(','))
    
    # разбиваем строку в поисках улиц, строений, прочих элементов
    address_parts_to_split = address_parts
    address_parts = []
    for address_part in address_parts_to_split:
        address_part = address_part.strip()
        address_part_split = re.findall(r'(?:[А-Я][^А-Я]+[\s-][А-Я][^А-Я]+)|(?:[А-Я][^А-Я]+)', address_part, flags=re.M)
        if len(address_part_split) > 1:
            address_parts.extend(address_part_split)
        elif len(address_part) > 0:
            address_parts.append(address_part)
    
    # поиск обозначения дома и его номера
    is_house_finded = False
    for house_subword in address_levels[-1]:
        house_split = re.split(r'%s' % house_subword, address_parts[-1], 1, flags=re.I | re.M)
        clean_house_subword = re.sub(r'[^\w\.]', '', house_subword)
        if len(house_split) > 1:
            is_house_finded = True
            address_parts = address_parts[:-1]
            if len(house_split[0]) > 0:
                address_parts.append(house_split[0])
            address_parts.append(clean_house_subword + ' ' + house_split[1])
    # если информация не найдена, добавляем хвост, предполагая, что в нём находится дом
    if not is_house_finded:
        merged_part = re.search(r'[^\d]\d', address_parts[-1])
        if merged_part != None:
            n = merged_part.span()[0] + 1
            value = address_parts[-1]
            address_parts = address_parts[:-1]
            address_parts.append(value[:n])
            address_parts.append(value[n:])
    
    # собираем данные
    dict_address = {}
    list_address = list(map(str.strip, address_parts))
    for list_address_part in list_address:
        if address_level_n < 5:
            # ограничиваем размер частей, для избежания больших строк
            dict_address[address_levels_name[address_level_n]] = list_address_part[:64]
            address_level_n += 1            
        else:
            break
    return dict_address

При нахождении числового значения, строка с адресом считается законченной и все данные из правой части отсекаются. Затем все найденные элементы строки собираются в адрес в нормализированном виде. Шаги алгоритма повторяются для каждой строки датафрейма, каждого датафрейма из коллекции.

Кроме описанного алгоритма, я тестово использовал алгоритм, основанный не на ключевых словах, а на формализованном синтаксисе записи адресов в русском языке. Данный алгоритм использует расстояние между символами, расположение больших букв, знаков препинания и числовых значений в конце адреса. В целом работоспособность второго алгоритма оказалась на уровне первого, поэтому в рамках статьи он не обозревается.

Сравнение

Для определения эффективности алгоритма было проведено сравнение с НЛП для поиска и извлечения информации из документов с "плохой" структурой в связке с проектом Natasha. Очевидно, что эффективность последних должна быть выше, но также потребуются данные для обучения, унифицированная структура, приведение к нормальному виду, в то время как описанные в статье алгоритмы работают с необработанными данными.

Основой НЛП для поиска и извлечения информации послужил проект sec-doc-info-extraction. В исходном виде в качестве входных данных он использует html файлы, в которых производится поиск ключевых фраз. Для задачи поиска адресов алгоритм модифицирован - вместо html файлов, обрабатывались excel файлы (соответственно pdf и word документы предварительно сконвертированы в формат excel), а в качестве ключевых слов использовались всё те же элементы структуры адреса. После обучения в целом можно сказать, что скрипт справлялся с поставленной задачей.

Далее, для определения частей адреса внутри строк среди найденных документов, использован метод описанный в статье "Обработка NL адресов для создания эффективных поисковых запросов при помощи набора инструментов проекта Natasha". В отличии от базовой версии Natasha, данный метод позволяет находить большее количество мест за счёт своих доработок (к примеру микрорайоны учитываются как часть адреса). При предварительной обработке данных и приведению их к унифицированному виду (что для тестовой выборки было сделано вручную) задача выполнялась успешно, но в случае с "сырыми" данными, возникала проблема либо с отсечением нужных данных, либо пропуском адреса в принципе, что ожидаемо при использовании "загрязнённых" данных.

Итого, на тестовой выборке получился следующий результат: описанный в статье алгоритм, несмотря на проблемы с полнотой данных, правильно отработал примерно в 70% случаев; в свою очередь модифицированная Natasha с чистыми данными правильно обработала адрес в 95% случаев, но с "плохими" адресами показатель упал до 50% случаев. При этом скорость работы была выше у модификации Natasha (изображение 4).

Вывод:

Несмотря на невысокую скорость работы, зависимость от качества данных, мой алгоритм поиска адресов, при минимальном количестве ресурсов и библиотек, достаточно успешно выполняет эту задачу. А какими способами Вы решаете подобные задачи?