Введение
Для проведения проверки мне необходимо было установить адреса нескольких сотен объектов недвижимости. Проблема в том, что адреса были написаны в разных частях документов, документы имели различные форматы, и сам адрес также мог быть написан разнообразными способами.
Да, существует возможность использовать для данной задачи различные библиотеки и сервисы, но источники данных с информацией об этих объектах должны быть упорядочены и однородны. Можно ли используя минимум ресурсов решать подобные задачи? Можно! Рассмотрим решение на основе 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).
Вывод:
Несмотря на невысокую скорость работы, зависимость от качества данных, мой алгоритм поиска адресов, при минимальном количестве ресурсов и библиотек, достаточно успешно выполняет эту задачу. А какими способами Вы решаете подобные задачи?