🤓Бартов: про работу с ИТ- и медтекстами и прочее

Формулы, которые нельзя просто отскриншотить

2026-10-07T20:45:00.091Z

Кстати, когда мы обсуждали заказ на перевод книги по теории информации, клиент предложил мне просто скриншотить формулы, чтобы он их потом вставил в книгу (MS Word).

— А как же локализация формул?
— Евгений, не пугайте меня. Их разве надо локализовать?
— Разумеется. Поэтому скриншотами не обойдёмся.

Попалась на глаза хорошая иллюстрация.

Возможно, кому-то будет полезно учитывать этот момент в обсуждении своих проектов.

Galois Field или как два плюс два превращаются в ноль

2026-10-07T18:09:18.399Z

Какие только мысли не приходят в голову, пока переводишь текстики. Вот внезапно вспомнилась хохма из моих школьных времен (1990-е годы): какие-то шутники-студенты каким-то хитроумным способом какому-то там профессору доказали, что 2 + 2 = 0. Ну и лопух же этот профессор, если повелся на такую глупость, думал я тогда.

И вот встречаю в тексте книги по теории информации фразу примерно такого содержания (перевод):

«…можно ли построить то же самое над любым коммутативным кольцом, где деление есть не всегда? В общем случае — нет, и виноваты "делители нуля" (zero divisors): ненулевые числа, которые в произведении с другим ненулевым числом дают ноль».

Учитывая, что тут упоминается свойство коммутативности (в школьном изложении оно звучит как «от перестановки слагаемых сумма не меняется»), в этой фразе содержится ничто иное, как то самое «шутливое» утверждение из моих школьных времён.

Так каким же образом может быть 2 + 2 = 0?

В моём конкретном случае речь идёт о полях Галуа (конечных полях).

Давние подписчики моего блога, возможно, помнят заметку об этом французском учёном — Эваристе Галуа — из начала XIX века. В 17 лет он решил задачу из высшей математики, над которой лучшие математические умы мира бились без малого три века до него. В некоторых книгах даже упоминается, что именно он стал основателем высшей математики. Увы, нелепо погиб на дуэли в 20 лет.

Отвлёкся. Так вот, о полях Галуа (Galois field) или о конечных полях.

Одна из идей конечных полей (finite fields) — это конечное число используемых чисел. Как только мы в своих подсчётах доходим до последнего числа, мы снова откатываемся на начало. Вот и получается: если в нашем поле всего четыре числа — 0, 1, 2, 3, — то 2 + 2 в нормальной математике дают 4, а поскольку в этом поле такого числа нет, то после 3 будет 0. Таким образом, мы и получаем: 2 + 2 = 0, или применительно к умножению 2 × 2 = 0.

Вот такая вот математика для гуманитариев типа меня :)

Надеюсь, было интересно.

Про локализацию листингов (кода) в книгах

2026-10-01T17:43:24.586Z

Про локализацию кода в стайлгайдах ИТ-компаний написано скупо. И то, что написано, мягко говоря, не учитывает массу edge cases.

Темы локализации промптов там нет вообще. А я на эти грабли наступил, когда переводил книгу Томажа Братанича «Основы GraphRAG. Улучшенный RAG на базе графов знаний».

Подробно про ту проблематику я сейчас расписывать не буду. Косвенно я её упомянул в телеграм-группе «Дебагеры Read IT Club» . Вот цитата:

Под листингами я понимаю следующие вещи:
1. Фрагменты кода / результаты его выполнения.
2. Логи/выводы команд.
3. Промпты/инференсы/выводы (в т.ч. системные и для взаимодействия с MCP).
4. Сообщения об ошибках.

Может, ещё что-то забыл — пожалуйста, дополните. Но, думаю, направление мыслей понятно.

С одной стороны, нельзя оставлять читателя без перевода — ему может быть непонятно.
С другой стороны, переводить даже значения строковых переменных опасно. Вдруг автору захочется посчитать в них слова, буквы или байты, отсортировать их или использовать строковые значения в качестве заголовков полей в БД (типа orders). Плюс нельзя упускать из виду такой момент: если вы в первой главе что-то перевели по определённому паттерну, то и до конца книги придётся переводить так же. Или не переводить вообще.

С промптами тоже всё неоднозначно. То, что прекрасно работает на английском в одной модели, может работать совсем не так — или совсем никак — на русском в этой же модели. И уж тем более в другой: мало ли на каких тренировочных сетах они выращивались.

С выводами выполнения команд тоже непросто. Вроде как там можно перевести, но надо, видимо, какое-то предупреждение для читателя выводить: этот перевод понарошку, в реальности он всё равно увидит на экране английские слова. Потому что этот шелл, справка или утилита на русский никогда не переводились — и вряд ли кому захочется оплачивать такой перевод.

•••

Жарких дискуссий мой вопрос не вызвал. Но сейчас я работаю над переводом книги Go In Action , и мне этот вопрос надо было как-то решать.

Поэтому, когда я в конце месяца сдавал наработку, он неизбежно возник в обсуждении с заказчиком.

Заказчик предложил переводить строковые значения там, где это безобидно. Например, если в книге даётся так:

... 

	// Look at the text one byte at a time.
	for i := 0; i < len(text); i++ {
		if text[i] == ' ' {
			numSpaces++
		}
	}

	fmt.Println("Found", numSpaces+1, "words")
}

То в переводе это должно выглядеть так:

...

	// Просматриваем текст по одному байту за раз.
	for i := 0; i < len(text); i++ {
		if text[i] == ' ' {
			numSpaces++
		}
	}

	fmt.Println("Найдено", numSpaces+1, "слов(а)")
}

Или если в командной строке вывод выглядит так:

$ ./wordcount
Found 4 words

То в переводе должен выглядеть так:

$ ./wordcount
Найдено 4 слов(а)

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

... 

	// Просматриваем текст по одному байту за раз.
	for i := 0; i < len(text); i++ {
		if text[i] == ' ' {
			numSpaces++
		}
	}

	fmt.Println("Found", numSpaces+1, "words") // Найдено <N> слов(а)
}

Или так:

$ ./wordcount
Found 4 words # Найдено 4 слова

Клиент не согласился:

- Это же не код ("Found 4 words"), а вывод программы. Так?

- Да, так. Только вы уверены, что дальше по тексту автору не захочется, например, превратить переведённое слово из строкового значения в переменную? В английском это запросто. Допустим, имеем такой листинг:

func main() {
	if len(os.Args) < 2 {
		log.Println("need to provide at least one filename!")
		os.Exit(1)
	}
}

Если мы дадим такой перевод:

func main() {
	if len(os.Args) < 2 {
		log.Println ("Нужно предоставить хотя бы одно имя файла!")
		os.Exit(1)
	}
}

то уже на следующем листинге мы получаем шах и мат:

for _, filename := range os.Args[1:] {
	file, err := os.Open(filename)
}

Видите, да? "filename" внезапно из строкового значения превратился в переменную filename. И что мы теперь будем делать с нашим "имя файла"?

И, чтобы далеко не отходить, рассмотрим наш исходный пример, где мы имеем те же метаморфозы со словом words:

func main() {
	text := "let's count some words!"
	words := strings.Fields(text)
	fmt.Println("Found", len(words), "words")
}

Если мы начнем строковые значения переводить, а переменные нет (а их точно нельзя переводить), мы и читателя запутаем, и сами запутаемся, и логику программы запросто сломаем.

Поэтому, чтобы не ломать эту логику, я и предлагаю все переводы давать в инлайновых комментариях (или не давать вообще):

func main() {
	text := "let's count some words!"          // давайте посчитаем слова!
	words := strings.Fields(text)      
	fmt.Println("Found", len(words), "words")  // Найдено <N> слов(а)
}

На том и договорились.

Надеюсь, было полезно.

Ваш Евгений Б.

Видеокомментарии к русско-английскому учебному переводу в сфере ИБ (выпуск от 09 апреля 2026 г.)

2026-09-30T12:33:23.205Z

Видео автора «Бартов: про работу с ИТ- и медтекстами и про всякое » в Дзене 🎦

#учимся_переводить

Продолжаю разбирать русско-английский учебный перевод вопросов к собеседованию на должность специалиста по ИБ, переводит технический писатель.

Разобрали вопросы/ответы №19-22. В этом выпуске я объясняю, среди прочих моментов, почему 'installer that supports PXE (Preboot eXecution Environment) network boot' это «масло масляное», почему переводчик правильно поступил, что не стал переводить в лоб «порт отключается и вы получаете сообщение», и почему «подкованный» — это всё же не tech-savvy.

Надеюсь будет интересно и познавательно.

P.S. По всем вопросам (обучение переводчиков, в т.ч. в вузах, автоматизация работы с текстами, переводы, копирайтинг и пр.) писать на bartov-e*yandex.ru или в мессенджеры (искать по телефону +79039550466)

Вайб-кодинг с отладкой

2026-09-30T08:02:56.967Z

Этот пост — для тех, кто пишет свои скрипты для автоматизации. Делюсь граблями и, возможно, приёмом, который помогает наступать на них реже.

Недавно выяснилось: я писал свои скрипты неправильно. Раньше как было?

Пишу запрос: «Сделай мне Python-скрипт, который делает то-то и то-то. И ещё вот это, это и это».
Дипсик что-то выкатывает. Пробегаю глазами по коду. Похоже на то, что я хотел, — вставляю в VS Code, запускаю. Поехали.
Вылазят ошибки. Они всегда вылазят. Скидываю лог, Дипсик думает, выдвигает версию и пишет что-нибудь в духе: «Ну вот теперь-то 200% заработает».
Запускаю снова. Что-то начинает работать, что-то перестаёт. Дальше — тяни-толкай: Дипсик правит две ошибки, попутно сносит логику двух других функций, появляются ещё две ошибки.

В эту игру можно играть долго. Каждый раз Дипсик авторитетно заявляет: «Ну вот сейчас я ВАЩЕ ВСЁ-ВСЁ-ВСЁ учёл, стопудово заработает». Ты запускаешь код — и он опять через минуту, пять, пятнадцать или сорок выбрасывает ошибку.

• • •

Как вы помните, я недавно писал статью для своего клиента про эксперимент с вайб-кодингом (статья, кстати, даже залетела в топ Хабра) , где клиент мне описывал фанатов ИИ, гоняющихся ~~за линией горизонта~~ за шансом ухватить версию работающего кода, глядя на обещания ИИ. Я узнал себя.

В разговоре, когда мы обсуждали саму статью, клиент сказал: реализовать тот или иной алгоритм программно — никаких проблем, с этим справится junior-разработчик.

Проблема не в этом. Проблема в том, что вокруг программной реализации алгоритма и «идеального сценария его использования» (happy path) нужно написать кучу сценариев того, как всё пойдёт не по плану. А это уже 95% оставшегося кода.

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

Выглядит это так. Пишу промпт:

Хочу Python-скрипт, который делает то-то и то-то (далее пошаговый идеальный алгоритм).
Проанализируй предложенную реализацию, выяви слабые и спорные места, предложи оптимизации.
Никогда не выводи код, пока не прояснишь все уточняющие вопросы. Код выводи только после моей команды «Выводи полный код».

• • •

И тут начинается нудный многочасовой допрос. Примеры из обсуждения скрипта для дедупликации книг в библиотеке:

— Хэширование текста без полного извлечения — принципиально? Предлагаю такую-то реализацию. Согласен?
— Что значит «уникальный файл»?
— Где живёт индекс? Как скрипт узнаёт, что файл «новый»?
— Что если имя файла уже содержит [Число_страниц]_? Убирать старый префикс и ставить новый? Или оставлять как есть?
— По твоему правилу выживает PDF (он в LIB\), а EPUB удаляется. Это правильно? Или EPUB всё-таки должен выжить — он ведь более редактируемый?
— Дубликаты внутри LIB\ тоже идут в _duplicates, а не в _trash?

Вопросы идут бесконечным, как кажется, потоком. Ответишь на двадцать — он найдёт слабые места в твоих ответах и сгенерирует ещё двадцать. Таких сессий вопросов-ответов может быть 20-30.

Главное — не давать себе слабину. Каждый раз, отправляя пачку ответов, снова и снова спрашивать:

Если есть ещё уточняющие вопросы, задавай.

• • •

В итоге Дипсик выдаёт заветное «Вопросов больше нет, я готов вывести код» — и выкатывает код, который работает почти сразу.

У меня возник всего один косяк: библиотеку Дипсик импортировал чуть позже, чем положено. Исправилось легко.

Эксперимент с таким допросом я провёл дважды: апдейтил скрипт для извлечения глоссария и вот этот, для дедупликации книг в библиотеке. Результатом пока доволен (на скриншоте лог работы скрипта, работает уже 12 часов без единой ошибки, со скоростью обработки примерно 32 файла/книги в минуту):

Таким образом, хоть ИИ и выкатывает за 2-3 минуты — это, как вы понимаете, самая финальная операция. А вот обсуждение параметров, ограничений и уточнений занимает 2-3 часа и больше даже на мелкий скрипт.

Надеюсь, кому-нибудь мой опыт помог.

Про автоматизацию набора книг через ИИ

2026-09-22T22:40:12.614Z

#nlp

Наверное, я бы не скоро ещё добрался до этого скрипта, но моя коллега меня к этому подтолкнула. Дело в том, что я ленивый, и книжки, которые перевожу, набираю не я, а моя коллега, Александра.

Я ей скидываю книги, которые мне присылает издательство на перевод, говорю что-то вроде: «Александра, я через пару дней буду пустой», что в переводе означает, что у меня заканчиваются подготовленные тексты на перевод, и она мне высылает свои наработки по набору.

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

Набирать самому — совершенно неохота. Распознавание через Finereader — это редкостный геморрой: сначала чистишь текст от артефактов распознавания, потом форматируешь. А у меня ещё в работе книжка по математике — та самая, которую я иногда упоминаю в заметках, — с многоэтажными и длинными формулами вот такого вида:

Такое даже файнридер не берет.

Но незадолго до всех этих событий я экспериментировал с DeepSeek: скормил ему копипасту из этих формул. Он их понял и вывел в LaTeX. Я поделился наблюдениями с Александрой — и она таким макаром подготовила мне несколько глав. Тоже, впрочем, муторно: в книге почти 750 страниц, обалдеешь столько копипастить и склеивать.

ЭТАП 1: ПЕРВЫЙ СКРИПТ

И я решил этот опыт автоматизировать. Взял книгу по программированию на Go — текст там примерно такого характера:

За несколько итераций навайбкодил скрипт. Он умеет следующее:

принимает путь к PDF-файлу плюс начальную и конечную страницы;
вытаскивает текст не просто копипастой, а с метатегами: где курсив, где жирный, где заголовок, где код;
чтобы не поперхнуться объемом и не жрать ресурсы, работает батчами по три странички;
дальше соединяется с DeepSeek.Chat по API и через промпт просит преобразовать копипасту с метаинформацией в Markdown-файл;
DeepSeek принимает под козырёк и выдаёт результат.

Два часа отладки — и три минуты работы скрипта. На выходе примерно 200 страниц набранного и отформатированного текста в Маркдауне:

Вот, собственно, и код на Python:

# %% [I. Imports]
import fitz  # PyMuPDF
import json
import os
import re
import base64
from openai import OpenAI
from PIL import Image
import io
print("✅ Cell 1: Imports loaded successfully.")

# ==============================================================================
# %% [CONFIGURATION CONSTANTS]
# ==============================================================================
PDF_PATH = r"H:\...\GoBook.pdf"
START_PAGE = 170  
END_PAGE = 374
PAGES_PER_CHUNK = 3
DEEPSEEK_API_KEY = "sk-..."
PROGRESS_FILE = "progress.json"

EXTRACT_IMAGES = True  
MIN_IMAGE_SIZE = 10000  
IMAGES_OUTPUT_FILE = "document_images_tables.md" # Explicit filename
print("✅ Cell 2: Configuration constants set.")

# ==============================================================================
# %% [API CLIENT INITIALIZATION]
# ==============================================================================
client = OpenAI(
    api_key=DEEPSEEK_API_KEY,
    base_url="https://api.deepseek.com"
)
print("✅ Cell 3: DeepSeek API client initialized.")

# ==============================================================================
# %% [SYSTEM PROMPTS]
# ==============================================================================
SYSTEM_PROMPT_TEXT = """
You are an expert assistant specialized in converting raw PDF text into clean, perfectly formatted Markdown.

CRITICAL RULES:
1. MERGE BROKEN LINES: Remove arbitrary line breaks within paragraphs. Merge lines to form continuous, flowing prose. ONLY use newlines for actual paragraph breaks, headings, lists, or code blocks.
2. HEADERS/FOOTERS: Aggressively DELETE running headers and footers. If you see a standalone page number (e.g., "164", "166") or a chapter title (e.g., "Chapter 7 Errors in Go") at the very beginning or end of a page chunk, REMOVE IT. It is not part of the main text.
3. CODE BLOCKS & CALLOUTS: PDF extraction often interleaves marginal notes (callouts) into the middle of code blocks. 
   - Reconstruct the code block as a SINGLE, valid Markdown code block (```go ... ```). 
   - Move any interrupting descriptive text (e.g., "**Function returning only an error**") to a bulleted list or blockquote IMMEDIATELY AFTER the code block.
4. HEADINGS & LISTINGS: Recognize patterns like "Listing 7.1" or "Chapter 7" and format them as Markdown headings (e.g., `### Listing 7.1: main.go`). Preserve `**bold**` formatting.
5. BULLETS: Convert weird bullet artifacts (like "¡", "", "•") into standard Markdown dashes (`- `).
6. NO SUMMARIZATION: Preserve 100% of the original information, logic, and technical depth.
7. NO META-TEXT: Output ONLY the cleaned Markdown. Do NOT output page markers like "[CONTEXT_MARKER: PAGE X]".
"""

SYSTEM_PROMPT_IMAGE = """
You are an expert OCR assistant specialized in extracting text from images and figures.

YOUR TASK:
1. Analyze the image and determine if it contains any text.
2. If text is present, extract it LINE BY LINE in the exact order it appears (top to bottom).
3. Format the output as a Markdown table with TWO columns:
   - Column 1: "Original Line" - the exact text from the image
   - Column 2: "Translation" - leave this column EMPTY (just a placeholder for future translation)

OUTPUT FORMAT EXAMPLE:
| Original Line | Translation |
|---------------|-------------|
| Compressor | |
| f: X\\to\\{0,1\\}^* | |

STRICT RULES:
- If NO text is detected, output exactly: "[NO_TEXT_DETECTED]"
- Do NOT describe the image. ONLY extract text.
- Preserve mathematical notation.
"""
print("✅ Cell 4: System prompts configured.")

# ==============================================================================
# %% [HELPER FUNCTIONS]
# ==============================================================================

def load_progress(pdf_path: str) -> int:
    """Loads progress ONLY if the PDF path matches. Prevents cross-file conflicts."""
    if os.path.exists(PROGRESS_FILE):
        try:
            with open(PROGRESS_FILE, "r", encoding="utf-8") as f:
                data = json.load(f)
                if data.get("pdf_path") == pdf_path:
                    return data.get("last_processed_page", START_PAGE - 1)
        except (json.JSONDecodeError, IOError):
            pass
    return START_PAGE - 1


def save_progress(pdf_path: str, page_num: int) -> None:
    """Saves progress with the PDF path to ensure file-specific tracking."""
    with open(PROGRESS_FILE, "w", encoding="utf-8") as f:
        json.dump({"pdf_path": pdf_path, "last_processed_page": page_num}, f)


def clean_pdf_artifacts(text: str) -> str:
    """Pre-processes text to fix math artifacts and weird bullet points."""
    # Fix math
    text = text.replace(" ∗", "^*").replace("∗", "^*")
    text = text.replace("→", "\\to ").replace("←", "\\gets ")
    
    # Fix weird bullets (inverted exclamation, dots, squares often found in PDFs)
    text = re.sub(r'^\s*[¡•▪▫]\s*', '- ', text, flags=re.MULTILINE)
    
    # Clean excessive spaces
    text = re.sub(r' {2,}', ' ', text)
    return text


def extract_formatted_text_from_pages(pdf_path: str, start: int, end: int) -> tuple:
    """Extracts text, merges lines to prevent mid-sentence breaks, and extracts images."""
    doc = fitz.open(pdf_path)
    text_chunks = []
    images_data = []
    
    for i in range(start - 1, end):
        page_num = i + 1
        page = doc[i]
        
        text_chunks.append(f"\n[CONTEXT_MARKER: PAGE {page_num}]\n")
        
        page_dict = page.get_text("dict")
        page_text_parts = []
        
        for block in page_dict.get("blocks", []):
            if block.get("type") == 0:  # Text block
                block_lines = []
                for line in block.get("lines", []):
                    line_parts = []
                    for span in line.get("spans", []):
                        text = span.get("text", "")
                        if not text.strip():
                            continue
                            
                        flags = span.get("flags", 0)
                        is_italic = bool(flags & 2)
                        is_bold = bool(flags & 16)
                        
                        text = clean_pdf_artifacts(text)
                        
                        if is_bold and is_italic:
                            line_parts.append(f"***{text}***")
                        elif is_bold:
                            line_parts.append(f"**{text}**")
                        elif is_italic:
                            line_parts.append(f"*{text}*")
                        else:
                            line_parts.append(text)
                    
                    # Join spans in a line with a space
                    block_lines.append(" ".join(line_parts))
                
                # Join lines within a block with a SPACE, not a newline.
                # This prevents mid-sentence line breaks. The LLM will handle paragraph splits.
                page_text_parts.append(" ".join(block_lines))
        
        text_chunks.append("\n\n".join(page_text_parts)) # Double newline separates distinct blocks
        
        # Image extraction
        if EXTRACT_IMAGES:
            print(f"   Scanning page {page_num} for images...")
            image_list = page.get_images(full=True)
            valid_images = []
            
            for img_index, img_info in enumerate(image_list):
                try:
                    xref = img_info[0]
                    base_image = doc.extract_image(xref)
                    img = Image.open(io.BytesIO(base_image["image"]))
                    if img.width * img.height >= MIN_IMAGE_SIZE:
                        valid_images.append((img, img_index))
                except Exception:
                    continue
            
            if valid_images:
                print(f"  📎 Found {len(valid_images)} valid image(s) on page {page_num}")
                for img, img_idx in valid_images:
                    print(f"    🖼️ Processing image {img_idx + 1}...")
                    try:
                        buffer = io.BytesIO()
                        img.save(buffer, format="PNG")
                        img_base64 = f"data:image/png;base64,{base64.b64encode(buffer.getvalue()).decode()}"
                        
                        response = client.chat.completions.create(
                            model="deepseek-chat",
                            messages=[
                                {"role": "system", "content": SYSTEM_PROMPT_IMAGE},
                                {"role": "user", "content": [{"type": "image_url", "image_url": {"url": img_base64}}, {"type": "text", "text": "Extract text to table."}]}
                            ],
                            max_tokens=1000,
                            temperature=0.1
                        )
                        extracted_text = response.choices[0].message.content.strip()
                        
                        if extracted_text != "[NO_TEXT_DETECTED]":
                            images_data.append({"page": page_num, "image_index": img_idx, "extracted_text": extracted_text})
                            print("    ✅ Text extracted.")
                        else:
                            print("    ⚪ No text detected.")
                    except Exception as e:
                        print(f"    ❌ Vision API error: {e}")
            else:
                print(f"  ✓ No valid images found on page {page_num}")
        
    doc.close()
    return "".join(text_chunks).strip(), images_data


def validate_length(original_text: str, markdown_text: str) -> tuple[bool, str]:
    """Validates the output length."""
    len_orig = len(original_text)
    len_md = len(markdown_text)
    if len_orig == 0: return True, "Empty original, skipping."
    
    ratio = len_md / len_orig
    if ratio < 0.8: return False, f"DATA LOSS! Ratio: {ratio:.2f}"
    if ratio > 2.5: return False, f"HALLUCINATION! Ratio: {ratio:.2f}"
    return True, f"Length OK (ratio: {ratio:.2f})"

print("✅ Cell 5: Helper functions defined.")

# ==============================================================================
# %% [MAIN PROCESSING LOOP]
# ==============================================================================

def process_pdf() -> None:
    print("=" * 60)
    print("🚀 STARTING PDF TO MARKDOWN PIPELINE")
    print("=" * 60)
    
    last_processed = load_progress(PDF_PATH)
    current_start = last_processed + 1
    
    if current_start > END_PAGE:
        print("✅ All requested pages for THIS FILE have been processed.")
        return

    base_name = os.path.splitext(PDF_PATH)[0]
    md_filename = f"{base_name}_clean.md"
    
    print(f"📁 Text output: {md_filename}")
    print(f"📁 Images output: {IMAGES_OUTPUT_FILE}\n")

    all_images_data = []

    while current_start <= END_PAGE:
        current_end = min(current_start + PAGES_PER_CHUNK - 1, END_PAGE)
        print("-" * 60)
        print(f"🔄 Processing chunk: Pages {current_start} to {current_end}")
        print("-" * 60)
        
        print("  [1/4] Extracting text and images...")
        raw_text, images_data = extract_formatted_text_from_pages(PDF_PATH, current_start, current_end)
        all_images_data.extend(images_data)
        
        if not raw_text.strip():
            print("  ⚠️ Chunk empty. Skipping.")
            current_start = current_end + 1
            save_progress(PDF_PATH, current_end)
            continue
        print("  ✅ Extraction complete.")

        print("  [2/4] Sending text to DeepSeek API...")
        try:
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=[
                    {"role": "system", "content": SYSTEM_PROMPT_TEXT},
                    {"role": "user", "content": raw_text}
                ],
                temperature=0.1
            )
            markdown_result = response.choices[0].message.content.strip()
            print("  ✅ Response received.")
        except Exception as e:
            print(f"  ❌ API Error: {e}")
            break

        print("  [3/4] Validating output...")
        is_valid, msg = validate_length(raw_text, markdown_result)
        if not is_valid:
            print(f"  🛑 HALTED: {msg}")
            break
        print(f"  ✅ {msg}")

        print("  [4/4] Saving results...")
        with open(md_filename, "a", encoding="utf-8") as f:
            f.write(markdown_result)
            f.write("\n\n")
        
        save_progress(PDF_PATH, current_end)
        print(f"  ✅ Saved and checkpointed: pages [{current_start}-{current_end}]")
        
        current_start = current_end + 1

    # Force save images file if any data exists
    if all_images_data:
        print("\n" + "=" * 60)
        print(f"💾 Saving {len(all_images_data)} image table(s) to: {IMAGES_OUTPUT_FILE}")
        print("=" * 60)
        try:
            with open(IMAGES_OUTPUT_FILE, "w", encoding="utf-8") as f:
                f.write("# Extracted Text from Images/Figures\n\n")
                f.write("Column 2 is intentionally left empty for translation.\n\n---\n\n")
                for img_data in all_images_data:
                    f.write(f"## Page {img_data['page']}, Image {img_data['image_index'] + 1}\n\n")
                    f.write(img_data['extracted_text'])
                    f.write("\n\n---\n\n")
            print("✅ Image tables saved successfully!")
        except Exception as e:
            print(f"❌ Failed to save images file: {e}")
    else:
        print("\n⚠️ No text-containing images were found in this run.")

    print("=" * 60)
    print("🎉 PIPELINE COMPLETED SUCCESSFULLY")
    print("=" * 60)


if __name__ == "__main__":
    # Clear old progress if you want to force re-run on the same file:
    # if os.path.exists(PROGRESS_FILE): os.remove(PROGRESS_FILE)
    process_pdf()
# %%

ЭТАП 2: ПРОБЛЕМА МАТЕМАТИЧЕСКИХ ФОРМУЛ

Дальше я решил таким же макаром подготовить математическую книгу. Указал путь, попробовал на одной главе — и обломался. DeepSeek почему-то отформатировал переменные в формулах просто как жирные или курсивные буковки: просто поставил вокруг них одну или две звёздочки в разметке Маркдауна, без всякой LaTeX разметки. Но блин, он же LaTeX-разметку формул мне уже делал. Что пошло не так?

После некоторого дебаггинга выяснилось: модель может делать что-то одно. Получает текст с метатегами форматирования — и буквы в формулах форматирует. Получает просто текст без разметки — видит формулы, ставит LaTeX, но понятия не имеет, где у меня жирный, где курсив: в простом тексте эти маркеры теряются.

ЭТАП 3: РЕШЕНИЕ — ДВУХПОТОЧНЫЙ ПРОМПТ (DUAL-INPUT)

Выкурив пару рюмок кофе, я нашел решение: отдавать в модель две копипасты — простой текст и с метатегами.

[RAW TEXT]: Простой текст без разметки. Модель использует его строго для идентификации математических формул, переменных и символов (чтобы понять, что "a 1 , a 2" — это $a_1, a_2$ ).

[FORMATTED TEXT]: Текст с правильной структурой абзацев, маркерами жирного/курсива и исправленными разрывами строк. Модель использует его как базу для структуры.

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

Вот как это выглядит в набранном виде — это скриншот текста в Маркдауне + LaTeX того куска, что я скриншотил выше:

Ну и сам код, тоже на Python:

# %% [I. Imports]import 
import fitz  # PyMuPDF
import json
import os
import re
import base64
from openai import OpenAI
from PIL import Image
import io
print("✅ Cell 1: Imports loaded successfully.")

# ==============================================================================
# %% [CONFIGURATION CONSTANTS]
# ==============================================================================
PDF_PATH = r"H:\...\Information Theory.pdf"
START_PAGE = 225
END_PAGE = 713
PAGES_PER_CHUNK = 3
DEEPSEEK_API_KEY = "sk-..."
PROGRESS_FILE = "progress_math.json"

EXTRACT_IMAGES = True  
MIN_IMAGE_SIZE = 10000  
print("✅ Cell 2: Configuration constants set.")

# ==============================================================================
# %% [API CLIENT INITIALIZATION]
# ==============================================================================
client = OpenAI(
    api_key=DEEPSEEK_API_KEY,
    base_url="https://api.deepseek.com"
)
print("✅ Cell 3: DeepSeek API client initialized.")

# ==============================================================================
# %% [SYSTEM PROMPTS]
# ==============================================================================
SYSTEM_PROMPT_TEXT = """
You are an expert assistant specialized in converting PDF text into perfect Markdown with LaTeX math.

YOU WILL RECEIVE TWO VERSIONS OF THE SAME TEXT:
1. [RAW TEXT]: Unformatted, preserves original character sequence. Use this STRICTLY to identify mathematical formulas, variables, and symbols (e.g., recognizing that "a 1 , a 2" means "$a_1, a_2$").
2. [FORMATTED TEXT]: Contains correct paragraph structure, bold/italic markers, and fixed line breaks. Use this as the BASE for your output.

YOUR TASK:
Merge the best of both. Output a single, clean Markdown document that:
- Uses the paragraph structure, lists, and bold/italic formatting from [FORMATTED TEXT].
- Corrects ALL mathematical notation into proper LaTeX (e.g., `$a_1$`, `$S^n$`, `$X = (S_1, \\dots, S_n)$`) based on the context from [RAW TEXT].
- Aggressively removes running headers, footers, and isolated bold page numbers (e.g., "**196**", "**Part II**").
- Preserves 100% of the original information. NO SUMMARIZATION.
- Outputs ONLY the final Markdown. Do NOT output the raw text or any meta-commentary.
"""

SYSTEM_PROMPT_IMAGE = """
You are an expert OCR assistant. Extract text LINE BY LINE from the image.
Format as a 2-column Markdown table: "Original Line" and "Translation" (leave empty).
If NO text is detected, output exactly: "[NO_TEXT_DETECTED]". Do NOT describe the image.
"""
print("✅ Cell 4: System prompts configured.")

# ==============================================================================
# %% [HELPER FUNCTIONS]
# ==============================================================================

def load_progress() -> int:
    if os.path.exists(PROGRESS_FILE):
        try:
            with open(PROGRESS_FILE, "r", encoding="utf-8") as f:
                data = json.load(f)
                if data.get("pdf_path") == PDF_PATH:
                    return data.get("last_processed_page", START_PAGE - 1)
        except (json.JSONDecodeError, IOError):
            pass
    return START_PAGE - 1

def save_progress(page_num: int) -> None:
    with open(PROGRESS_FILE, "w", encoding="utf-8") as f:
        json.dump({"pdf_path": PDF_PATH, "last_processed_page": page_num}, f)

def extract_raw_text_for_context(pdf_path: str, start: int, end: int) -> str:
    """Extracts plain text without any markdown formatting, preserving original spacing for math context."""
    doc = fitz.open(pdf_path)
    text_chunks = []
    for i in range(start - 1, end):
        page = doc[i]
        # "text" mode gives raw string, we just clean extreme artifacts
        raw = page.get_text("text")
        raw = raw.replace("ﬁ", "fi").replace("ﬂ", "fl")
        text_chunks.append(raw)
    doc.close()
    return "\n".join(text_chunks).strip()

def merge_lines_smartly(block_lines: list) -> str:
    if not block_lines:
        return ""
    merged = [block_lines[0].strip()]
    for i in range(1, len(block_lines)):
        prev_line = block_lines[i-1].strip()
        curr_line = block_lines[i].strip()
        if not curr_line:
            continue
        if re.search(r'[.!?]\s*$', prev_line):
            merged.append("\n\n" + curr_line)
        else:
            merged.append(" " + curr_line)
    return "".join(merged)

def remove_programmatic_headers_footers(text: str) -> str:
    text = re.sub(r'\n\s*\*\*\d+\*\*\s*\n', '\n', text)
    text = re.sub(r'\n\s*\*\*Part II\*\*\s*\n\s*\*\*Lossless Data Compression\*\*\s*\n', '\n', text, flags=re.IGNORECASE)
    text = re.sub(r'\n{3,}', '\n\n', text)
    return text.strip()

def extract_formatted_text_from_pages(pdf_path: str, start: int, end: int) -> str:
    """Extracts text with bold/italic markers and smart line merging."""
    doc = fitz.open(pdf_path)
    page_text_parts = []
    
    for i in range(start - 1, end):
        page = doc[i]
        page_dict = page.get_text("dict")
        block_texts = []
        
        for block in page_dict.get("blocks", []):
            if block.get("type") == 0:
                block_lines = []
                for line in block.get("lines", []):
                    line_parts = []
                    for span in line.get("spans", []):
                        text = span.get("text", "")
                        if not text.strip():
                            continue
                            
                        # Fix ligatures early
                        text = text.replace("ﬁ", "fi").replace("ﬂ", "fl")
                        
                        flags = span.get("flags", 0)
                        is_italic = bool(flags & 2)
                        is_bold = bool(flags & 16)
                        
                        if is_bold and is_italic:
                            line_parts.append(f"***{text}***")
                        elif is_bold:
                            line_parts.append(f"**{text}**")
                        elif is_italic:
                            line_parts.append(f"*{text}*")
                        else:
                            line_parts.append(text)
                    
                    block_lines.append(" ".join(line_parts))
                
                merged_block = merge_lines_smartly(block_lines)
                if merged_block:
                    block_texts.append(merged_block)
        
        page_text_parts.append("\n\n".join(block_texts))
    
    doc.close()
    raw_formatted = "\n\n".join(page_text_parts)
    return remove_programmatic_headers_footers(raw_formatted)

def extract_formatted_text_and_images(pdf_path: str, start: int, end: int) -> tuple:
    """Wrapper that gets formatted text and handles images."""
    formatted_text = extract_formatted_text_from_pages(pdf_path, start, end)
    images_data = []
    
    if EXTRACT_IMAGES:
        doc = fitz.open(pdf_path)
        for i in range(start - 1, end):
            page_num = i + 1
            page = doc[i]
            print(f"   Scanning page {page_num} for images...")
            image_list = page.get_images(full=True)
            valid_images = []
            for img_index, img_info in enumerate(image_list):
                try:
                    xref = img_info[0]
                    base_image = doc.extract_image(xref)
                    img = Image.open(io.BytesIO(base_image["image"]))
                    if img.width * img.height >= MIN_IMAGE_SIZE:
                        valid_images.append((img, img_index))
                except Exception:
                    continue
            
            if valid_images:
                print(f"  📎 Found {len(valid_images)} valid image(s) on page {page_num}")
                for img, img_idx in valid_images:
                    print(f"    🖼️ Processing image {img_idx + 1}...")
                    try:
                        buffer = io.BytesIO()
                        img.save(buffer, format="PNG")
                        img_base64 = f"data:image/png;base64,{base64.b64encode(buffer.getvalue()).decode()}"
                        response = client.chat.completions.create(
                            model="deepseek-chat",
                            messages=[
                                {"role": "system", "content": SYSTEM_PROMPT_IMAGE},
                                {"role": "user", "content": [{"type": "image_url", "image_url": {"url": img_base64}}, {"type": "text", "text": "Extract text to table."}]}
                            ],
                            max_tokens=1000,
                            temperature=0.1
                        )
                        extracted_text = response.choices[0].message.content.strip()
                        if extracted_text != "[NO_TEXT_DETECTED]":
                            images_data.append({"page": page_num, "image_index": img_idx, "extracted_text": extracted_text})
                            print("    ✅ Text extracted.")
                    except Exception as e:
                        print(f"    ❌ Vision API error: {e}")
            else:
                print(f"  ✓ No valid images found on page {page_num}")
        doc.close()
        
    return formatted_text, images_data

def validate_length(original_text: str, markdown_text: str) -> tuple[bool, str]:
    len_orig = len(original_text)
    len_md = len(markdown_text)
    if len_orig == 0: return True, "Empty original, skipping."
    ratio = len_md / len_orig
    if ratio < 0.8: return False, f"DATA LOSS! Ratio: {ratio:.2f}"
    if ratio > 2.5: return False, f"HALLUCINATION! Ratio: {ratio:.2f}"
    return True, f"Length OK (ratio: {ratio:.2f})"

print("✅ Cell 5: Helper functions defined.")

# ==============================================================================
# %% [MAIN PROCESSING LOOP]
# ==============================================================================

def process_pdf() -> None:
    print("=" * 60)
    print("🚀 STARTING PDF TO MARKDOWN PIPELINE (DUAL-INPUT MODE)")
    print("=" * 60)
    
    last_processed = load_progress()
    current_start = last_processed + 1
    
    if current_start > END_PAGE:
        print("✅ All requested pages for THIS FILE have been processed.")
        return

    base_name = os.path.splitext(PDF_PATH)[0]
    md_filename = f"{base_name}_clean.md"
    images_md_filename = f"{base_name}_images_tables.md"
    
    print(f"📁 Text output: {md_filename}")
    print(f"📁 Images output: {images_md_filename}\n")

    all_images_data = []

    while current_start <= END_PAGE:
        current_end = min(current_start + PAGES_PER_CHUNK - 1, END_PAGE)
        print("-" * 60)
        print(f"🔄 Processing chunk: Pages {current_start} to {current_end}")
        print("-" * 60)
        
        print("  [1/4] Extracting DUAL text versions and images...")
        raw_text = extract_raw_text_for_context(PDF_PATH, current_start, current_end)
        formatted_text, images_data = extract_formatted_text_and_images(PDF_PATH, current_start, current_end)
        all_images_data.extend(images_data)
        
        if not formatted_text.strip():
            print("  ⚠️ Chunk empty. Skipping.")
            current_start = current_end + 1
            save_progress(current_end)
            continue
        print("  ✅ Extraction complete.")

        print("  [2/4] Sending DUAL-INPUT to DeepSeek API...")
        try:
            # Combine both texts into a single, structured prompt
            combined_user_prompt = f"""
[RAW TEXT - Use for math context only]:
{raw_text}

---

[FORMATTED TEXT - Use as base structure]:
{formatted_text}
"""
            response = client.chat.completions.create(
                model="deepseek-chat",
                messages=[
                    {"role": "system", "content": SYSTEM_PROMPT_TEXT},
                    {"role": "user", "content": combined_user_prompt}
                ],
                temperature=0.1
            )
            markdown_result = response.choices[0].message.content.strip()
            print("  ✅ Response received.")
        except Exception as e:
            print(f"  ❌ API Error: {e}")
            break

        print("  [3/4] Validating output...")
        # Validate against formatted text length, as it's closer to the expected output
        is_valid, msg = validate_length(formatted_text, markdown_result)
        if not is_valid:
            print(f"  🛑 HALTED: {msg}")
            break
        print(f"  ✅ {msg}")

        print("  [4/4] Saving results...")
        with open(md_filename, "a", encoding="utf-8") as f:
            f.write(markdown_result)
            f.write("\n\n")
        
        save_progress(current_end)
        print(f"  ✅ Saved and checkpointed: pages [{current_start}-{current_end}]")
        current_start = current_end + 1

    if all_images_data:
        print("\n" + "=" * 60)
        print(f"💾 Saving {len(all_images_data)} image table(s)")
        print("=" * 60)
        try:
            with open(images_md_filename, "w", encoding="utf-8") as f:
                f.write("# Extracted Text from Images/Figures\n\n")
                f.write("Column 2 is intentionally left empty for translation.\n\n---\n\n")
                for img_data in all_images_data:
                    f.write(f"## Page {img_data['page']}, Image {img_data['image_index'] + 1}\n\n")
                    f.write(img_data['extracted_text'])
                    f.write("\n\n---\n\n")
            print("✅ Image tables saved successfully!")
        except Exception as e:
            print(filed to save images file: {e}")
    else:
        print("\n⚠️ No text-containing images were found in this run.")

    print("=" * 60)
    print("🎉 PIPELINE COMPLETED SUCCESSFULLY")
    print("=" * 60)

if __name__ == "__main__":
    # if os.path.exists(PROGRESS_FILE): os.remove(PROGRESS_FILE)
    process_pdf()
# %%

Итог обработки оставшихся 500 страниц:

Время обработки: ~15 минут.
Стоимость (токены API): ~150 рублей.

Совсем неплохо, как считаете?

Спасибо а внимание! Надеюсь, было познавательно.

Post 09/22/2026

2026-09-22T21:23:30.994Z

Недавно я цитировал Линуса Торвальдса применительно к нашим переводческим реалиям. Фраза мне эта попалась на глаза не потому, что я фанат Линуса, а потому что мы в это время с коллегой писали статью о любопытном эксперименте — один большой поклонник возможностей ИИ заявил, что программисты не нужны, т.к. ИИ способен нагенерить систему любой сложности за пару недель.

Моего клиента это задело за живое, он предложил этому поклоннику ИИ показать его слова в деле.

В целом, все, что написано в статье, в том или ином виде можно параллелить на нашу переводческую специфику (и в свое заметке я именно это и сделал).

Даю ссылку на Хабре, чтобы вы могли сами сделать свои выводы — https://habr.com/ru/articles/1085382/. Там нет особо технических деталей, там больше размышления о том, в каких местах иллюзия о возможностях ИИ начинает трещать по швам и разваливаться, а также куда нужно тыкать и смотреть, чтобы реально оценивать потолок возможностей ИИ.

#портфолио

18 оттенков термина 'distance' (из теории информации)

2026-09-21T19:26:27.264Z

#заметки_на_полях

Продираясь через смыслы книги по теории информации из моей прошлой заметки, я заметил, что в этой дисциплине много разных "дистанций" (distance). Я насчитал 18 штук, пришлось отложить перевод в сторону и разложить их по полочкам у себя в голове. Поехали.

1. Попарное расстояние / Pairwise Distance

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

Это и есть попарное расстояние — не какой-то особый способ измерения, а сам принцип оценивания дистанции между каждой парой объектов в наборе данных.

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

2. Евклидово расстояние / Euclidean Distance

Окей. Как измерять это расстояние? Самое первое, что приходит в голову - померять расстояние линейкой по карте. То есть берем карту страны, проводим прямую линию от одного участника к другому. Ну или берем глобус - и тоже проводим мысленно линию. Вот эта дистанция по прямой в двухмерном или трехмерном пространстве - которую мы так часто считали в школе на уроках геометрии — и будет Евклидово расстояние.

В теории информации оно воспринимается чуток иначе — данные представляются в виде точек в пространстве (ну типа, по осям можно отложить рост, вес и возраст участника).

Евклидово расстояние тогда будет считаться между точками и в таком случае покажет, насколько участники антропометрически похожи друг на друга.

Тут правда есть большой минус — если один параметр сильно вырастет, он перетянет все внимание на себя.

3. Квадрат евклидова расстояния / Squared L2-Distance

Иногда в математике прямая линия — это неудобно из-за знака корня в формуле Пифагора. Так вот если мы просто не будем извлекать корень, мы получим квадрат евклидова расстояния (или squared L2). В чем плюс такого подхода?

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

Вот в теории информации этот квадрат используется постоянно: он сильнее наказывает за большие ошибки, чем за маленькие. Если вы промахнулись на 2 см, штраф будет 4, а если на 5 см — штраф уж 25.

Такой подход помогает алгоритмам более агрессивно искать возможности, чтобы избежать огромных сбоев при передаче сигналов.

4. Манхэттенское расстояние (Расстояние L1) / L1-Distance

Но что делать, если «по прямой» ходить нельзя? Представьте, что вы бродите по улицам Нью-Йорка, которые образуют ровные кварталы.

Чтобы дойти до нужного дома, придется идти строго зигзагами: три квартала на север, два квартала на восток. Сумма этих шагов называется расстоянием L1 (или Манхэттенским расстоянием).

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

5. Геодезическое расстояние / “Geodesic” Distance

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

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

6. Взвешенное «расстояние» / Weighted “Distance”

Вернемся на переводческую тусовку: мы выбираем, с кем договориться о встрече кулуарно, оценивая «дистанцию интересов» с тем или иным участником. Но для вас любовь участника к техническим дисциплинам имеет огромный вес, а то, какой рисунок кавычек предпочитает коллега — почти нулевой.

Вот вы и умножаете важные различия на большой коэффициент, а неважные — на крошечный. Это называется взвешенным расстоянием.

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

7. Расстояние Хэмминга / Hamming Distance

Перейдем от чисел к тексту. Вы переписываетесь в чате и делаете страшную опечатку: вместо слова «извИните» отправляете «извЕните». К счастью, ваш собеседник не граммар-наци и без проблем понимает вас. Почему?

Потому что между этими словами расстояние Хэмминга равно единице — ровно в одной позиции буквы различаются. Расстояние Хэмминга считает количество несовпадающих символов в двух строках одинаковой длины. Мы часто это видим в «кошках» типа Trados/Smartcat, когда вызываем функцию Concordance.

Это база в теории кодирования: когда файлы летят по интернету, из-за помех «10110» может превратиться в «10010». Посчитав расстояние Хэмминга между отправленным и полученным кодом, принимающий компьютер может рассчитать, сколько битов исказилось, и исправить ошибку.

8. Расстояние полной вариации / TV-Distance (Total Variation Distance)

Представьте, что вы с другом по дороге на форум решили зайти в клуб игровых автоматов. У вас шансы выиграть золото, серебро или бронзу составляют [60%, 30%, 10%], а у друга — [40%, 40%, 20%]. Насколько различаются ваши игровые условия в целом?

Расстояние полной вариации находит самое большое возможное различие в вероятностях для одного и того же события (в нашем случае — для золота: 60% - 40% = 20%). Это самый простой и строгий способ сказать: «Два этих случайных процесса отличаются максимум на столько-то процентов».

9. Расстояние Хеллингера / Hellinger Distance

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

Если менее абстрактно, то представьте, что вы с другом сравниваете свои библиотеки по жанрам. Если вы читаете только иронические детективы, а он — только Стругацких и Лема, то расстояние Хеллингера будет равно 1.

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

10. Расстояние Бхаттачарьи / Bhattacharyya Distance

Это близкий родственник расстояния Хеллингера, но он скорее оценивает степень наложения (overlap).

Например, врач-диагност сравнивает графики распределения плотности тканей на снимках здорового органа и органа с патологией. Расстояние Бхаттачарьи покажет, насколько эти графики пересекаются.

Если графики распределения вероятностей вообще не пересекаются, это расстояние уходит в бесконечность.

В теории информации и компьютерном зрении его используют, чтобы оценить, насколько легко алгоритм может перепутать два класса объектов (например, кошку и собаку на размытом фото).

11. Дивергенция (Дистанция расхождения) / Divergence Distance

Отойдем немного в сторону непривычных вещей. Дело в том, что в теории информации часто нужны «расстояния», которые не работают как обычная линейка.

Мы привыкли, что от головы удава до хвоста удава расстояние будет тем же, что и от хвоста до головы — 38 попугаев.

В дивергенциях путь туда и путь обратно — это разные вещи (т. е. нарушается закон симметрии), поэтому слово «расстояние» тут частенько пишется в кавычках.

Возьмем, скажем, дистанцию между ошибками. Если вы переводите незнакомую тему, то ошибиться в термине, котором вы видите впервые — это нормально. Но ошибиться в термине из темы, с которой ты работаешь 30 лет — это катастрофа.

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

Дивергенции учитывают эту асимметрию направления и расстояние расхождения между реальностью и нашими представлениями.

12. Расстояние Кульбака — Лейблера / KL Distance (Kullback–Leibler Divergence

Самый знаменитый пример дивергенции и самый частый гость в ИТ-текстах про нейросети и LLM (включая ChatGPT). Представьте, что вы решили закодировать все свои сообщения другу, используя короткие символы для частых слов (типа «привет», «как») и длинные для редких. Но вы взяли статистику частоты слов из словаря Даля, а не из Тик-тока.

Расстояние Кульбака-Лейблера (KL-дивергенция) измерит, сколько лишних битов вы потратите на передачу сообщений из-за того, что ваша модель представлений о языке не совпадает с истинным распределением слов у молодежи (Тик-ток).

Она показывает плату за наше незнание или неточную оценку вероятностей.

13. Минимальное расстояние Ятракоса . Yatracos’ Minimum-Distance

Представьте, что перед вами кусок текста со случайными словами, и вы пытаетесь угадать, по какому закону они там перемешиваются/складываются. У вас есть несколько математических моделей-кандидатов. Как выбрать лучшую, если слов слишком много и они слишком запутанные?

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

Минимальное расстояние Ятракоса — это специальный инструмент для подбора идеальной модели. Оно строит особую коллекцию «тестовых вопросов» (кубиков данных) и смотрит, какая из ваших моделей дает наименьшее отклонение от реальности (эмпирических данных) по всем тестам одновременно.

14. Минимальное расстояние Фитингофа / Fitingof Minimal Distance

Этот термин из мира сжатия данных и архиваторов (вроде ZIP, RAR и т. п.). Представьте, что вы набрали на клавиатуре случайный набор букв «АААБББААА». Насколько этот текст далек от абсолютно хаотичного, несжимаемого шума?

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

15. Расстояние Вассерштейна (Метрика «землекопа») / Wasserstein Distance (Earth Mover's Distance)

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

Это и есть расстояние Вассерштейна (в английском языке у этого термина более народный синоним — Earth Mover's Distance — дистанция землекопа).

В более научном применении, можно представить, что у вас есть одно распределение пикселей (скан МРТ пациента год назад) и второе распределение (скан сегодня). За год ткани немного сместились, опухоль уменьшилась. Обычные метрики скажут, что картинки «абсолютно разные», потому что пиксели не совпадают один в один.

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

16. Расстояние Синкхорна / Sinkhorn Distance

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

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

Это сглаженное и гораздо более быстро вычисляемое расстояние называется расстоянием Синкхорна.

Именно благодаря ему алгоритмы в машинном обучении могут довольно быстро, нередко в реальном времени, сопоставлять огромные массивы информации, переводить тексты и обрабатывать графику. Например, с его помощью сопоставляются белки, ищутся молекулы-кандидаты для лекарств и алайнятся многоязычные параллельные тексты.

17. Расстояние Орнштейна / Ornstein’s Distance (d-bar distance)

Теперь усложним задачу для алгоритма Вассерштейна. Представьте, что вы сравниваете не просто статичные кучи песка, а целые кинофильмы или непрерывные кардиограммы, где буквы/символы/данные зависят друг от друга (например, в английском после Q часто идет U). Как измерить разницу между двумя такими процессами во времени?

Расстояние Орнштейна (или d-метрика) — это способ применить идею «минимальной переделки» к случайным последовательностям. Оно определяет, какой минимальный процент букв в длинном изменяющемся потоке данных нужно перезаписать, чтобы один случайный процесс стал неотличим от другого с сохранением всей его внутренней структуры и зависимостей.

18. Расстояние Ле Кама / Le Cam Distance

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

Если расстояние Ле Кама между двумя моделями экспериментов близко к нулю, это значит, что они содержат одинаковое количество полезной информации и следовательно — асимптотически эквивалентны.

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

Иными словами, это расстояние показывает границы нашей способности познавать мир по неполным данным.

Можно сделать вывод, что термин «distance» в ИТ и теории информации — это не физическое «расстояние», а мера различия, ошибки или информационного расхождения.

Спасибо за внимание! Надеюсь было познавательно.

Про локализацию нерелевантных данных

2026-09-21T19:17:19.398Z

#локализация

В книге про программы-вымогатели, перевод которой уже близится к концу, я был вынужден прибегнуть к одному приему, который многим коллегам-переводчикам может показаться спорным.

И тем не менее, учитывая склонность автора к постоянным повторам одних и тех же мыслей (типичная черта американских авторов), мне приходится то там, то сям как-то урезать эту «болтовню».

Речь о перечислении локальных организаций, которые могут помочь бизнесу в восстановлении после атак или в противодействии им. Автор явно рассчитывал свою книгу на аудиторию западных стран, Россию там он в качестве целевой аудитории не рассматривал (более того, там страной происхождения почти всех программ-вымогателей указана Россия, хорошо, хоть «Осью Зла» нас не называет), поэтому он часто эти организации перечисляет. Вот как это выглядит:

или так:

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

Малый бизнес в США может обратиться в CISA за бесплатной поддержкой через Cloud Hygiene Scanner (888-863-8656). Аналогичные бесплатные инструменты и консультации есть в Великобритании (NCSC), Австралии (ACSC) и ЕС (ENISA).

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

Спасибо за внимание! Надеюсь было познавательно.

Про избыточную локализацию

2026-09-21T18:40:48.965Z

#заметки_на_полях

#локализация

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

В силу профдеформации я часто обращаю внимание на локализацию в переводах. Недавно дочь купила книгу «Куколки» (оригинал: «Chrysalids» / Джон Уиндем) — про постапокалипсис, я такое люблю.

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

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

Зато в одном фрагменте мой взгляд зацепился за довольно странный выбор имен:

Снова появилась миссис Уэндер и увела Софи в другую комнату. Когда мистер Уэндер зашел за тюками в следующий раз, я двинулся за ним.

Две лошади, Пятнышко и Рыжик, терпеливо стояли около дома, часть вещей уже была навьючена на них.

На мой взгляд здесь локализация получилась не очень удачно. Чтобы лучше пояснить свои соображения, приведу цитату из книги Корнея Чуковского (он не только для детей писал книжки, но и для переводчиков):

Переводчица Диккенса М.А. Шишмарева напрасно влагает в уста англичанам русские простонародные слова. Странно читать, как британские джентльмены и леди говорят друг другу: «И мы не лыком шиты…», «Батюшки!», «Пропала моя головушка!», «Тю-тю!» И даже (незаметно для себя) цитируют стихи Грибоедова, вряд ли очень популярные в Англии: «Я это делаю с толком, с чувством, с расстановкой».

Когда герои Диккенса поют: «Иппи-дол-ли-дол, иппи-дол-ли-дол, иппи-ди», – Е.Г. Бекетова переводит: «Ай люли! ай люли! Разлюлюшеньки мои».

Здесь я увидел похожую ситуацию: имена лошадей локализованы — "Пятнышко" (Spot) и "Рыжик" (Sandy) — вряд ли их так англичане называют, но при этом имя девочки нет (она же Софи, а не София). Если так хочется сказать по раскраску лошадей, можно локализовать в духе пятнистый Спот и рыжая Сэнди. Но в книге они упоминаются один раз, поэтому можно было бы вообще их не переводить (просто сказать - две лошади) или пренебречь их окраской (она тоже никак на сюжет не влияет).

В другой переведенной книге этого же автора «Кукушки Мидвича»/«Кукушата Мидвича» (The Midwich Cuckoos) мое внимание привлекло еще одно несколько странное предложение:

Вот наша убыль: мистер Уильям Транк, батрак, его жена и ребенок, сгоревшие вместе со своим домом; пожилая чета Стигфилдов, также погибшая в результате пожара; еще один батрак, Герберт Флэгг, найден умершим от переохлаждения...

Простите, кто? Батраки? Они-то откуда в Великобритании взялись? Это чисто российская/советская реалия. С таким же успехом можно и фермера колхозником называть. В оригинале farm-hand - работник фермы.

Продолжение следует.

P.S. Кстати, видите странность в локализации этой фразы? Какую? Подсказка: пропущенный перевод police cars я вижу, но я не про него сейчас, тут нюанс поинтереснее.

On both the Oppley and Stouch roads there was a great starting up and warming of engines. Presently two streams of ambulances, fire appliances, police cars, jeeps, and military trucks started to converge on Midwich.

На дорогах в Оппли и Стауч громко ревели моторы — их прогревали. Двумя потоками в Мидвич вливались машины «скорой», пожарные машины, джипы и военные грузовики.

Спасибо за внимание! Надеюсь было познавательно.