Обновить
1024K+

Python *

Высокоуровневый язык программирования

522,98
Рейтинг
Сначала показывать
Порог рейтинга

Почему цена почти доходит до TP, но разворачивается

Будущее это вероятностная функция от прошлого. ATR это чистая функция от прошлого. Разница в том, что в вероятностной функции есть коэфициент случайности и точно прогнозировать можно только лучший и худший случай

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

//@version=5
strategy("Стратегия с TP по ATR")

...

tpPrice    = entryPrice + atrMultTP * atr // Это не работает

Выходить из позиции при просадке PNL на заранее известный процент статистически предсказуемо.

listenActivePing(async ({ symbol, data }) => {
  const peakProfitDistance = await getPositionHighestProfitDistancePnlPercentage(symbol);
  const currentProfit = await getPositionPnlPercent(symbol);

  if (currentProfit < 0) {
    return;
  }

  if (peakProfitDistance < TRAILING_TAKE) {
    return;
  }

  await commitClosePending(symbol, {
    id: "unknown",
    note: str.newline(
      "# Позиция закрыта по trailing take",
    ),
  });
});

Тут есть разница: в отличие от классического trailing take где выход из позиции ставится на цену, которая каждый раз разная, отклонение PnL - постоянная величина

Теги:
Всего голосов 6: ↑6 и ↓0+6
Комментарии0

Паттерны проектирования еще актуальны?

Вокруг все чаще говорят, что ИИ скоро будет писать код за нас. Логичный вопрос — нужны ли тогда паттерны? Зачем разбираться в паттернах GoF, если нейросеть и так сгенерирует рабочий код по описанию?

У меня ощущение обратное.

Я плотно вошел в разработку в 2019 году. Переходил из 1С в .NET. Книги по паттернам GoF у меня были, но долго лежали как «книга на полке». Казалось, они оторваны от повседневных задач. Теорию вроде понимал, но не видел, где это реально применяется.

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

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

Из этого и вырос мой pet-project gofinsights.com. Я делаю его тренажером по паттернам проектирования. Не просто «прочитал и забыл», а через практику, сравнение решений и постепенное распознавание типовых архитектурных ходов.

Сейчас там есть интерактивный квиз, где можно проверить базу и не перепутать Factory Method с Abstract Factory. Дальше хочу развивать проект в сторону более глубокого ИИ-разбора. Чтобы можно было не только узнавать паттерн, но и разбирать кодовые запахи, причины проблем и возможную эволюцию решений.

Как вы это видите? Паттерны проектирования все еще рабочая база для разработчика? Или с появлением ИИ они станут менее важны?

Теги:
Всего голосов 6: ↑5 и ↓1+6
Комментарии1

Разрываем шаблоны: строим график с разрывом всего на 65 строк

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

Самые ходовые решения этой проблемы — разорванная ось (broken axis) или отдельные бины для аномалий. Проблема в том, что в Matplotlib нет готовой «кнопки» для создания гистограммы с разрывом. Но это легко* собирается руками на уровне нескольких осей.

Вот три рабочих подхода — выбирайте под свою задачу.

  1. Официальный пример из документации Matplotlib. 🔗 Ссылка на гайд. Отлично работает, когда выбросы зашкаливают по одной оси (X или Y). В посте разбирается как раз такой случай: гистограмма с волнистой линией обрыва.

  2. Библиотека brokenaxes делает почти всё сама. Устанавливается стандартно через pip. Вариант для тех, кто не хочет углубляться в ручную настройку.

  3. Логарифмическая шкала (часто — самый простой выход) Если выбросы строго положительные и отличаются на порядки, иногда достаточно двух строк: plt.xscale(«log») или plt.yscale(«log»). Никаких разрывов, никакой ручной работы — при этом график остаётся чистым и читаемым.

import matplotlib.patches as mpatches
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.path import Path


def plot_broken_axis(
    labels: list[str],
    values: tuple[float, ...],
    ylim_low=(0, 12),
    ylim_high=(20, 25),
    **kwargs,
):
    """
    Строит график с разрывом оси.
    Валидирует входные данные и инкапсулирует логику отрисовки.
    """
    if len(labels) != len(values):
        raise ValueError("Длины labels и values не совпадают")

    fig, (ax_high, ax_low) = plt.subplots(
        nrows=2, figsize=(7, 4), gridspec_kw={"height_ratios": [1, 2]}
    )

    # Настройки столбцов
    kwargs.setdefault("color", "skyblue")
    kwargs.setdefault("edgecolor", "black")
    kwargs.setdefault("alpha", 0.85)

    ax_low.bar(labels, values, **kwargs)
    ax_high.bar(labels, values, **kwargs)
    fig.subplots_adjust(hspace=0.0)

    # Настройка осей
    ax_low.set_ylim(*ylim_low)
    ax_high.set_ylim(*ylim_high)
    ax_high.set_title("График с разрывом")
    ax_low.set_ylabel("Рейтинг в %")
    ax_low.set_xlabel("Языки")
    ax_high.spines["bottom"].set_visible(False)
    ax_low.spines["top"].set_visible(False)
    ax_high.tick_params(axis="x", bottom=False, labelbottom=False)
    # Рисуем разрыв оси (волна)
    offset, n_points = 0.03, 33
    pts = np.linspace(-offset, 1 + offset, n_points)
    wave = np.array([1 + (0, offset, 0, -offset)[i % 4] for i in range(n_points)])
    path = Path(list(zip(pts, wave)), [Path.MOVETO] + [Path.CURVE3] * (n_points - 1))

    opts = dict(transform=ax_low.transAxes, clip_on=False, zorder=10)
    ax_low.add_patch(mpatches.PathPatch(path, lw=6, **opts))
    ax_low.add_patch(mpatches.PathPatch(path, lw=3, edgecolor="white", **opts))
    return fig


if __name__ == "__main__":
    langs = ["Python", "C", "C++", "Asm"]
    pops = (21.8, 11.1, 8.6, 1.1)

    # Стиль xkcd
    with plt.xkcd(scale=1, length=300, randomness=30):
        plt.rcParams["font.family"] = "Comic Sans MS"

        # Вызов функции
        fig = plot_broken_axis(langs, pops)
        plt.show()

Литература:

  • Документация Matplotlib. 🔗 Ссылка на гайд

  • Bernd Klein. Numerisches Python Arbeiten mit NumPy, Matplotlib und Pandas

  • Sandro Tosi. Matplotlib for Python Developers

Теги:
Всего голосов 5: ↑5 и ↓0+7
Комментарии0

Как читать статьи с arXiv на русском без лишних усилий

Если вы работаете с машинным обучением или исследовательскими задачами, arXiv, скорее всего, — ваш основной источник свежих идей.

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

В этом посте — два практичных способа читать статьи с arXiv в HTML‑формате прямо в браузере и сразу переводить их на русский с помощью встроенного перевода. Никаких LLM, сторонних ботов и скачивания PDF.

Зачем вообще HTML, если есть PDF

Классический сценарий работы с arXiv выглядит так: вы открываете страницу статьи, скачиваете PDF и читаете его в отдельной программе или через встроенный viewer браузера.

У такого подхода есть несколько минусов:

  • Неудобно переводить: нужно копировать текст или использовать отдельные инструменты.

  • Плохо искать по странице: текст может быть нераспознанным или разбитым.

  • Тяжелее читать на маленьких экранах, особенно на ноутбуках и планшетах.

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

Способ 1. Официальный HTML (experimental)

У части статей на arXiv есть встроенная HTML‑версия.Если она включена, справа на странице вы увидите кнопку «HTML (experimental)».

Что это даёт:

  • статья открывается как полноценная HTML‑страница;

  • формулы остаются корректными;

  • можно использовать встроенный перевод в браузере.

Ограничения:

  • HTML‑версии есть не у всех препринтов.

  • Иногда верстка «плывёт», особенно в сложных таблицах.

Способ 2. ar5iv (если HTML нет)

Если кнопки HTML (experimental) нет, можно воспользоваться сторонним сервисом ar5iv из экосистемы arXiv Labs. Он автоматически конвертирует TeX‑исходники статей в HTML.

Идея простая: вы берете обычный URL arXiv и меняете в домене букву x на 5.

Пример:

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

Теги:
Всего голосов 3: ↑3 и ↓0+3
Комментарии5

Python на флешке: как собрать портативную среду без установки

Такой вариант хорошо подходит, если нужно:

  • показать скрипт на чужом компьютере;

  • поработать на машине без прав администратора;

  • запускать Python в ограниченной среде;

  • держать рядом интерпретатор, проект и зависимости в одном месте.

На корпоративных ПК всё зависит от политики безопасности. Если запуск с USB, .exe или PowerShell ограничен, портативная сборка тоже может не стартовать.

Что нужно

Минимальный набор простой:

  • USB-накопитель;

  • Windows x64;

  • доступ в интернет, если планируете ставить дополнительные пакеты.

Скачиваем Python

Идём на официальную страницу загрузок Python и берём Windows embeddable package (64-bit) для нужной версии, например, python-3.14.4-embed-amd64.zip.
После распаковки вы получите что-то вроде этого:

F:\
└── python3.14\
    ├── python.exe
    ├── python314.dll
    ├── python314._pth
    ├── python314.zip
    └── ...

На этом этапе интерпретатор уже можно запускать прямо с флешки.

Что делает _pth

Файл python314._pth управляет тем, какие пути Python видит при запуске. По умолчанию embeddable package изолирован от системного окружения, реестра и установленных пакетов.

Если вам нужно подключить локальные библиотеки, можно прописать пути вручную:

python314.zip
.
Lib
Lib\site-packages
import site

Строка import site нужна, чтобы Python начал использовать site-механику и подхватывать дополнительные каталоги.

Как добавить pip

У embeddable package pip обычно не идёт «из коробки» как в обычной установке.
Его можно добавить вручную через официальный bootstrap-скрипт get-pip.py.

Сценарий такой:

  1. Скачайте get-pip.py.

  2. Положите его рядом с python.exe.

  3. Запустите:

PS F:\> cd ./python3.14
PS F:\python3.14> ./python get-pip.py

После этого проверьте:

./python -m pip --version
# Выведет версию pip (например, pip 26.0.1).

Ставим пакеты

Когда pip уже доступен, можно ставить нужные библиотеки:

PS F:\python3.14> ./python -m pip install numpy pandas matplotlib seaborn requests

Или сразу из requirements.txt:

PS F:\python3.14> ./python -m pip install -r requirements.txt

Запускаем проект

Чтобы не помнить длинные пути, удобно сделать run.bat в корне флешки:

@echo off
cd /d %~dp0
set PYTHON_HOME=%~dp0python3.14
set PATH=%PYTHON_HOME%;%PATH%

%PYTHON_HOME%\python.exe my_project\main.py
pause

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

Типичная структура

Обычно папка на флешке выглядит так:

F:\
├── python3.14\
│   ├── python.exe
│   ├── python314.dll
│   ├── python314._pth
│   ├── python314.zip
│   └── Lib\site-packages\
├── my_project\
│   ├── main.py
│   └── requirements.txt
├── run.bat
Теги:
Рейтинг0
Комментарии2

🌲 Открываем регистрацию на Дебаг Кемп

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

📅 6–7 июня 2026 (выходные) 👥 Всего 25 мест — маленький формат, это принципиально.

Цена растёт по мере приближения к дате. Оплатить можно частями через сплит → регистрация

Если вы 💎 практик сообщества — скидка 15% применяется при регистрации автоматически. Ещё не практик, но думаете? Сейчас самый разумный момент.

👀 Узнать больше · 📝 Регистрация

Вопросы — в чат, мы там живём.

Теги:
Всего голосов 4: ↑0 и ↓4-4
Комментарии0

Голем: как в нём устроен анализ кода

В прошлый раз я рассказал про Голема — кодинг-агента в Telegram. Сейчас хочу показать, что у него под капотом. А именно — как работает анализ кода.

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

Нужно было что-то менять.

Гибридный анализ: четыре утилиты вместо одной LLM

Теперь перед тем, как отдать код модели, его прогоняют четыре статических анализатора:

bandit, ruff, semgrep, pip_audit = await asyncio.gather(
    run_bandit(project_dir),      # безопасность
    run_ruff(project_dir),        # стиль и баги
    run_semgrep(project_dir),     # глубокий анализ
    run_pip_audit(project_dir)    # зависимости
)

Каждая утилита отвечает за свою область:

  • Bandit ищет уязвимости безопасности: SQL-инъекции, использование eval(), хардкод паролей.

  • Ruff проверяет стиль и очевидные ошибки: неиспользуемые импорты, синтаксис, голые except.

  • Semgrep находит сложные паттерны: XSS, утечки данных, опасную десериализацию.

  • pip-audit сверяет зависимости с базой CVE и сообщает о дырявых пакетах.

Все четыре запускаются параллельно через asyncio.gather. На проекте среднего размера это занимает 10-15 секунд вместо 40-50 при последовательном запуске.

LLM получает только проблемные строки

Раньше модель получала первые 1000 символов из каждого файла. Это приводило к двум проблемам: дикий перерасход токенов и галлюцинации. LLM видела обрывок функции и думала, что код незавершённый.

Теперь всё иначе. Анализаторы возвращают конкретные проблемные строки, и модель получает только их с контекстом в 3-4 строки вокруг:

# main.py:42 — Bandit HIGH
query = f"SELECT * FROM users WHERE id = {user_input}"  # SQL-инъекция

Результат:

  • Расход токенов сократился в 10 раз.

  • Галлюцинации про «незавершённый код» исчезли полностью.

  • Анализ работает одинаково быстро на проекте из 10 файлов и из 500.

Асинхронный режим

ZIP-архивы и GitHub-репозитории анализируются в фоне. Пользователь отправляет файл и сразу получает ответ «анализ запущен», а результат приходит отдельным сообщением через минуту-две. Бот не висит, можно продолжать с ним работать.

asyncio.create_task(
    _analyze_directory_async(context, temp_dir, source, llm, user_id)
)
await update.message.reply_text("🔍 Анализ запущен в фоне")

Что дальше

Сейчас Голем умеет анализировать только Python-проекты. В ближайших планах:

  • Поддержка JavaScript/TypeScript (ESLint + npm audit)

  • Поддержка Go (golangci-lint + govulncheck)

  • Поддержка Rust (clipp +cargo-audit )

Также хочу добавить команду /fix — автоматическое исправление проблем, которые находит Ruff. Часть ошибок можно починить без участия человека, и Голем будет делать это сам.

Попробовать

Бот живёт в Telegram: @Golem666bot
Там же можно посмотреть другие проекты и следить за разработкой: @system_develope

Теги:
Всего голосов 1: ↑1 и ↓0+1
Комментарии0

Как отключить reasoning у локального DeepSeek-R1 и не сойти с ума

Третий пост из серии про грабли локальных LLM. Первый — про микрочанки, отравляющие RAG. Второй — про embedding модель, которая не знает русский. Сейчас — про reasoning, который жрёт ресурсы и не выключается.

Проблема

DeepSeek-R1-Distill-Qwen-32B — reasoning модель. На каждый запрос она сначала «думает» в блоке <think>...</think>, потом отвечает. Выглядит так:

<think>
Хорошо, мне нужно помочь пользователю распределить задачи
для проекта создания цифрового двойника для молочной фермы.
Я новичок в этом, поэтому постараюсь разобраться шаг за шагом.

Сначала, мне нужно понять, что такое цифровой двойник...
</think>

Разработка цифрового двойника для молочной фермы — это сложный проект...

Блок <think> может быть длиннее самого ответа. Это токены, это время, это VRAM. Для задач где рассуждения не нужны — чистый оверхед.

Наивное решение — не работает

Первая идея: убрать <think> из ответа регуляркой постфактум.

response_text = re.sub(r'<think>.*?</think>', '', response_text, flags=re.DOTALL).strip()

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

Решение от сообщества

Пустой блок <think>\n\n</think> в конце промпта. Модель видит, что фаза рассуждений уже «завершена», и сразу переходит к ответу.

text = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
text = text + "<think>\n\n</think>\n\n"

Попробовал — не работает. Reasoning остаётся.

Ловушка с токенизатором

Смотрю в лог что реально уходит модели:

...ть задачи?<|Assistant|><think><think>

</think>

Два <think>. Токенизатор DeepSeek при add_generation_prompt=True уже добавляет <think> в конец промпта автоматически. Мой код добавляет второй. Модель видит незакрытый первый тег и начинает думать.

Причём <|Assistant|> — это не обычные символы |, а полноширинные юникодные . Специальные токены DeepSeek. Если искать обычный | в строке — не найдёте.

Правильное решение

Проверять, что уже есть в промпте, и действовать по ситуации:

def prepare_prompt_no_thinking(messages, tokenizer):
    text = tokenizer.apply_chat_template(
        messages, 
        tokenize=False, 
        add_generation_prompt=True
    )
    
    if "<think>\n\n</think>" in text:
        pass  # Уже закрыт
    elif "<think>" in text and "</think>" not in text:
        text = text + "\n\n</think>\n\n"  # Закрываем открытый
    else:
        text = text + "<think>\n\n</think>\n\n"  # Добавляем пустой
    
    return text

Три ветки — потому что разные версии токенизатора ведут себя по-разному. Кто-то добавляет <think>, кто-то нет.

Результат

Без тегов:

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

С правильными тегами:

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

Модель сразу отвечает по делу, без вступительных рассуждений. Экономия токенов и времени — в зависимости от запроса от 30% до 60%.

Вывод

Если используете DeepSeek-R1-Distill локально и reasoning вам не нужен — не режьте его регуляркой постфактум. Закройте <think> тег до генерации. Но обязательно проверяйте, что токенизатор уже добавил — иначе получите дубль и потратите час на дебаг того, что должно было занять минуту.

Теги:
Всего голосов 3: ↑2 и ↓1+2
Комментарии3

Идеальная база знаний, а RAG возвращает мусор — проблема не там, где кажется

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

Контекст

Строю локальную мультиагентную систему. Собрал базу знаний: 85 архитектурных блоков, 160 чанков в ChromaDB, реальный опыт — не синтетика. Embedding модель — стандартная all-MiniLM-L6-v2. Документы на русском с вкраплениями английских терминов (DPO, LoRA, VRAM — как у всех).

Симптом

Спрашиваю: "DPO патч для OOM" — в базе есть целый блок про это. RAG возвращает документ про права доступа к Project Context. Вообще мимо.

Спрашиваю: "positive feedback loop" — в базе есть блок №57 ровно с таким названием. RAG его не находит, dist=0.746.

Диагностика

Подозрение — embedding модель не понимает русский текст. Проверяю: один и тот же смысл, три формулировки.

queries = [
    ("positive feedback loop", "английский"),
    ("петля положительной обратной связи", "русский"),
    ("цикл доверие данные результат", "русский контекст"),
]

for q, lang in queries:
    results = col.query(query_texts=[q], n_results=1, include=["documents", "distances"])
    dist = results['distances'][0][0]
    print(f"[{lang}] dist={dist:.3f} | '{q}'")
[английский]       dist=0.746 | 'positive feedback loop'
[русский]           dist=0.566 | 'петля положительной обратной связи'
[русский контекст]  dist=0.504 | 'цикл доверие данные результат'

Один смысл — разница в полтора раза. При этом документы в базе на русском. Английский запрос к русским документам — модель не может их сопоставить.

Почему так

all-MiniLM-L6-v2 обучалась на английских текстах. Она превращает текст в вектор из 384 чисел. Для английского — вектор осмысленный, семантически правильный. Для русского — видит буквы, но не понимает смысл. Вектор получается случайный.

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

А может перевести всё на английский?

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

Но для локальной системы с русскими документами это плохой вариант. Технические термины с контекстом теряются при переводе. Появляется двойная задержка — перевод запроса туда, результата обратно. Нужен ещё один сервис (переводчик), а задача — держать всё локально. И главное — ошибки накапливаются: плохой перевод → плохой вектор → плохой результат.

Для чисто английских доков — да, держите всё на английском. Но когда документы изначально на русском с кучей специфики — мультиязычная модель проще. Меньше движущихся частей.

Решение

Заменил all-MiniLM-L6-v2 на paraphrase-multilingual-MiniLM-L12-v2. Модель обучена на 50+ языках, включая русский. Понимает смешанный текст типа “DPO обучение на LoRA адаптере” — то, что в локальных ML-проектах встречается на каждом шагу.

Пересоздал все коллекции с новой моделью. Результат:

# Было (all-MiniLM-L6-v2):
# 'positive feedback loop' → dist=0.746, нашёл мусор

# Стало (multilingual):
# 'positive feedback loop' → dist=0.35, нашёл именно блок про Feedback Loop

Поиск заработал сразу. На все запросы — и русские, и английские, и смешанные.

Вывод

Если строите RAG на русском (или любом не-английском) — не берите all-MiniLM-L6-v2 по дефолту. Она стоит первой в каждом туториале, но для нелатинских языков это ловушка. Данные могут быть идеальными, чанкинг правильным, а поиск будет возвращать мусор — потому что “переводчик” не знает ваш язык.

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

# Было
ef = SentenceTransformerEmbeddingFunction(model_name="all-MiniLM-L6-v2")

# Стало
ef = SentenceTransformerEmbeddingFunction(model_name="paraphrase-multilingual-MiniLM-L12-v2")
Теги:
Всего голосов 5: ↑4 и ↓1+3
Комментарии5

3 мусорных документа (1.7%) отравили весь мой RAG

Строю локальную мультиагентную систему с RAG на ChromaDB. В какой-то момент модель начала нести чушь — вставлять в ответы куски маркдауна, генерить мусор вместо нормальных ответов.

Симптом

Спрашиваю: «Новый проект: цифровой двойник нефтеперерабатывающего завода. Как декомпозировать?»

В ответе — рандомные огрызки разметки типа "25*\n*Тип: Инфраструктура и системное администрирование*". Модель явно копировала что-то из контекста.

Копаю

Смотрю что RAG возвращает на этот запрос:

results = rag.query(query_texts=[query], n_results=3)
for doc in results['documents'][0]:
    print(f"[{len(doc)} chars]: {doc[:50]}")
[56 chars]: 25*\n*Тип: Инфраструктура и системное администр...
[15 chars]:  и реализация*...
[11 chars]: ров вместе...

Топ-3 — мусор, а не документы.

Причина

При загрузке маркдаун-файлов в ChromaDB чанкер резал по 800 символов механически — посередине заголовков, посередине предложений. В итоге появились микро-огрызки типа "ров вместе" (11 символов), которые стали отдельными документами.

Почему короткие чанки ломают RAG

Короткий текст → странный эмбеддинг. Вектор ни о чём, без смысла. И именно поэтому он оказывается «близок» к любому запросу случайным образом. Мой 11-символьный огрызок стабильно обгонял нормальные 800-символьные документы в similarity search.

Фикс

Нашёл все документы меньше 100 символов:

all_docs = rag.get(include=["documents"])
short = [(i, doc) for i, doc in enumerate(all_docs['documents']) if len(doc) < 100]
print(f"Мусор: {len(short)}")  # 3

Удалил:

ids_to_delete = [all_docs['ids'][i] for i, _ in short]
rag.delete(ids=ids_to_delete)
# Было: 176 docs → Стало: 173 docs

Галлюцинации прекратились сразу.

Вывод

Фильтруйте чанки по минимальной длине до загрузки в векторную БД:

MIN_CHUNK_LENGTH = 100
chunks = [c for c in chunks if len(c) >= MIN_CHUNK_LENGTH]

3 документа из 176 — это 1.7%. Процент не имеет значения. Если у мусора странный вектор — он всплывёт. Один плохой документ может отравить весь ваш RAG.

Теги:
Всего голосов 6: ↑4 и ↓2+3
Комментарии5

Как я научил Telegram-бота помнить то, что LLM положено забывать

LLM по своей природе — без памяти. Каждый новый диалог с ChatGPT, Claude или DeepSeek начинается с чистого листа. Разработчики пытаются решать это костылём: запихивают в контекст последние N сообщений.

Но это не память. Это дорогое, конечное и очень прожорливое контекстное окно. Хранить всю историю — разоришься на токенах. Учить модель на лету — пока фантастика.

Поэтому я сделал по-другому.

Встречайте: настоящая долговременная память для Golem (В том виде, в каком она нужна кодинг-агенту)

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

Как это работает:

  • /remember текст — Golem сохраняет факт в SQLite

  • /recall — показывает все ваши заметки

  • /forget ID — удаляет ненужное

Заметки автоматически подгружаются в начало каждого запроса, работают в любой сессии и переживают перезапуски бота. Никакой магии — просто грамотная архитектура.

Реальные примеры из жизни:

Вы пишете: /remember Я работаю над проектом X на Django + PostgreSQL. Никогда не предлагай MongoDB.

Через неделю спрашиваете: «Как оптимизировать запросы?» — Golem сразу учитывает стек и не несёт чушь про NoSQL.

Или: /remember Голем, не отвечай на вопросы про погоду. Это тупо.

Теперь на «какая погода?» он спокойно посылает вас в Google и не жрёт токены.

Это сильно круче простого увеличения контекста: вы сами решаете, что важно, а что — мусор.

Хотите видеть, как я дальше развиваю память (векторный поиск, автоматическое извлечение фактов и другие смелые эксперименты, которые я обкатываю прямо сейчас)?

→ Подписывайся на основной канал «СИСТЕМА»

Там я показываю внутреннюю кухню разработки Golem, полные архитектурные разборы и то, что обычно не выношу на Хабр.

Где потрогать бота прямо сейчас: https://t.me/Golem666bot

Пробуйте, ломайте, кидайте в комментариях:

  • Какие факты вы бы хотели, чтобы бот помнил о вас?

  • Каких ещё фич не хватает идеальному AI-ассистенту?

Жду ваших кейсов и идей — лучшие разберём вместе с Golem.

Теги:
Всего голосов 9: ↑0 и ↓9-9
Комментарии2

Написал небольшой микросервис на FastAPI, помогающий взаимодействовать с блокчейном Litecoin для принятия платежей. Сервис напрямую подключается к любой ноде на протоколе ElectrumX.

Список нод можно взять здесь: https://1209k.com/bitcoin-eye/ele.php?chain=ltc
Либо же можно захостить свою ноду, но пока нам будет достаточно удалённой.

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

Можем взглянуть на исходный код и перейдём к обзору функционала.
https://github.com/CryptoWrapAPI/litecoin-wallet-rpc

Для начала нужно получить свой ключ к блокчейну, проще говоря, сид-фразу.
Но не каждая сид фраза подойдёт, вкратце, нужна сид фраза стандарта BIP39.
Такую сид фразу можно сгенерировать с помощью new_wallet.py

Для этого нам понадобится Python версии 3.12, потому что библиотека bip_utils пока что поддерживает только эту версию.

Mnemonic string: 
rather nasty bright aisle craft spare blood room village resource special region winter gesture despair slender tiger wall state fashion grass trophy crack monster

Master key (bytes): 865fcb279555a25bf50e2e33d37ef68b363b3eb322a68456609526f80be28a7e
Master key (extended): zprvAWgYBBk7JR8GkiSjUUwyhei9mSTEMd5ENS9xywYxsf6WLuFvq9eJjE7eFCjw3sT4AreK7cRiBgF4x8CiL5sPUhwZA3rBhFbKD1poA3iWQCg
Master key (WIF): T7ZBZxkT8ebmYHyz1vHdG9G4of2UPJm2hVky1x19kX2xtQSKKCu4

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

Отправляем его вместе с account index и address index на эндпоинт /derive (запустим тест python tests/test_derive.py)

Индексы мы можем представить как координаты адреса по оси X и Y

============================================================
TEST: Address Derivation
============================================================
XPRV: zprvAWgYBBk7JR8GkiSj...
Account index: 0
Address index: 0

Status: 200
Response:
{
  "address": "ltc1qt25zdkgj4shgyp4xw770hsjtdph6kn70zz8h06",
  "account_index": 0,
  "address_index": 0,
  "chain": "external"
}

✓ Derived address: ltc1qt25zdkgj4shgyp4xw770hsjtdph6kn70zz8h06
============================================================

Теперь этот адрес кошелька можно отправить клиенту нашего сервиса.

Чтобы проверить, поступил ли платеж, мы можем обратиться к методу get_history
https://electrumx.readthedocs.io/en/latest/protocol-methods.html#blockchain-scripthash-get-history

// В этом примере адрес начинается с tltc1 вместо ltc1 
// Потому что это testnet блокчейн :)
// Сменить testnet/mainnet можно в .env

  "tltc1qayq6ppmzztpgy354r45lkp8vjdafnhtf0yhutm": {
    "transactions": [
      {
        "tx_hash": "6803c0769c89e2cd9bbbda1d1e8715c5b11c1e69f8f9a7d46c1cd6adc2103c6a",
        "height": 4672171
      },
      {
        "tx_hash": "10bdb766e7c8a42e468862a97b10260955fafe7a0fcd219f025b4dd105077e5e",
        "height": 4672208
      }
    ],
    "count": 2,
    "timestamp": "2026-04-10T01:23:37.448442+00:00"
  }

Мы видим две транзакции, height здесь - это номер блока, в который включена транзакция, если она всё ещё находится в мемпуле (ожидает подтверждения майнерами), то мы увидим -1 или 0.

Частота блоков в Litecoin составляет ~2 минуты. То есть примерно через 2 минуты транзакция будет включена в цепочку блоков.

Узнать детали транзакции можно с помощью эндпоинта /transactions
Там будет подробное описание транзакции, включая все "входы" и "выходы", количество отправленных монет, комиссию сети, заплаченную отправителем и так далее.

На этом у меня всё, спасибо за внимание!

Теги:
Всего голосов 3: ↑3 и ↓0+3
Комментарии0

Подключайся ко второму онлайн-митапу MWS для Python-разработчиков 🎙️

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

Будет интересно Python-разработчикам, аналитикам и другим ИТ-специалистам, кто интересуется применением ИИ в разработке.

Теги:
Рейтинг0
Комментарии0

Ближайшие события

Собери свой OpenClaw за вечер - гайд за 18 шагов

OpenClaw - самый быстрорастущий опенсорс-проект в истории GitHub. 350k звезд за пять месяцев, обогнал React, Linux и все остальное. Персональный AI-ассистент, который живет на твоей машине, работает через WhatsApp/Telegram/Slack/iMessage, выполняет команды в шелле, управляет браузером, отправляет почту, работает по расписанию. Если еще не слышали, советую попробовать.

Мне всегда интересно попробовать собрать что-то своими руками, особенно нравится ковыряться и настраивать ИИ агентов - есть в этом ощущение управления собственными сотрудниками. К чему я это, ловите интересный репозиторий - build-your-own-openclaw.

Что за репозиторий

Это пошаговый туториал из 18 этапов, где ты собираешь свою версию OpenClaw с нуля. Именно послойная сборка - каждый шаг добавляет одну концепцию и содержит работающий код + README с объяснением архитектурных решений. Шанс разобраться как устроен такой популярный бот.

Можно выделить четыре фазы:

Фаза 1 - одиночный агент. Начинаешь с голого чат-лупа. Потом подключаешь инструменты (read/write/bash - вот и основа для уже для большого скоупа задач). Затем навыки через SKILL.md, персистентность сессий, слеш-команды, компактификация истории, веб-инструменты.

Фаза 2 - event-driven архитектура. Агент выходит за пределы CLI. Горячая перезагрузка конфигов, каналы (теперь можно писать агенту с телефона), WebSocket для программного взаимодействия.

Фаза 3 - автономность и мультиагентность. Маршрутизация задач между агентами, cron + heartbeat (агент работает, пока спим или заняты делами), многослойные промпты, dispatch между агентами.

Фаза 4 - продакшн. Контроль конкурентности и долговременная память.

Почему это полезно может быть полезно?

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

  • Как строится цикл принятия решений.

  • Как агент выбирает инструменты.

  • Как компактифицируется контекст, когда история перестает влезать в окно.

  • Как появляется ощущение «интеллекта» из вполне механических частей.

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

Туториал написан на Python, использует LiteLLM для абстракции провайдеров. Можно пройти за вечер-два, если не застревать на каждом шаге.

РепозиторийСайт туториала

Надеюсь тебе понравилось. Лучшая благодарность - это твоя подписка на мой Telegram-канал 😊

Теги:
Всего голосов 4: ↑2 и ↓20
Комментарии0

Анализ истории сделок на предмет перекоса шортистов/лонгистов

Ссылка на GitHub

В backtest-kit модуль volume-anomaly используется как источник в графе сигналов - параллельно с GARCH. Если GARCH отвечает на вопрос «достаточно ли ожидаемое движение», то volume-anomaly отвечает на вопрос «является ли прямо сейчас статистически необычным моментом в микроструктуре рынка».

Пример кода

import { sourceNode, outputNode } from '@backtest-kit/graph';
import { predict } from 'volume-anomaly';
import { getCandles } from 'backtest-kit';

const ANOMALY_CONFIDENCE = 0.75;
const N_TRAIN  = 1200; // обучающее окно — должно быть без аномалий
const N_DETECT = 200;  // окно детекции

const reversalSource = sourceNode(
  async (symbol) => {
    // Важно: recent не должен пересекаться с historical
    const all        = await getAggregatedTrades(symbol, N_TRAIN + N_DETECT);
    const historical = all.slice(0, N_TRAIN);  // старые сделки — baseline
    const recent     = all.slice(N_TRAIN);     // новые — без overlap

    return predict(historical, recent, ANOMALY_CONFIDENCE);
    // {
    //   anomaly:    true,
    //   confidence: 0.81,
    //   direction:  'long' | 'short' | 'neutral',
    //   imbalance:  0.61,
    // }
 },
);

const entrySignal = outputNode(
  async ([reversal, ...]) => {
    if (!reversal.anomaly) return null;
    if (reversal.direction === 'neutral') return null;

    const position = reversal.direction; // 'long' | 'short'

    return {
      id: randomString(),
      position,
      priceTakeProfit: ...
      priceStopLoss: ...
      minuteEstimatedTime: 60,
    };
  },
  reversalSource,
  ...
);

Ключевые детали

  • Hawkes Process - кластеризация ордеров

  • CUSUM- сдвиг buy/sell дисбаланса относительно исторической нормы

  • BOCPD- смена режима: момент когда распределение дисбаланса само меняется

Как использовать

Классическая проблема DCA - ты усредняешься в падающий нож. Цена идёт против, ты докупаешь, а она продолжает падать. volume-anomaly заточен именно под это: докупать не по расписанию или по сетке уровней, а только когда ордерфлоу показывает разворот агрессии.

Теги:
Всего голосов 4: ↑3 и ↓1+2
Комментарии0

Golem хамоватый кодинг агент в Telegram

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

Это и есть Golem 666 — мой Telegram-бот, который анализирует код жёстко, без соплей и политкорректности.

Сейчас он уже умеет:

  • Пожирать проекты в .zip и анализировать их

  • Искать баги, уязвимости и архитектурные косяки

  • Давать конкретные рекомендации по исправлению

  • Работать в стриминговом режиме (сообщения приходят по мере генерации)

  • Сам постить отчёты в свой Telegram-канал

  • Ну и конечно пишет скрипт по запросу

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

В ближайших планах:

  • Автоматическое создание репозитория на GitHub

  • Автодеплой после успешного ревью кода

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

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

#python #ai #telegram #coding #golem

Теги:
Всего голосов 5: ↑0 и ↓5-5
Комментарии7

О прогнозе нейтрального тренда актива

Ссылка на GitHub

Две полоски - лучший и худший случай, его можно прогнозировать
Две полоски - лучший и худший случай, его можно прогнозировать

В backtest-kit GARCH используется как один из источников в графе сигналов. Идея: вход открывается только если GARCH-канал достаточно широк, чтобы TP и SL уместились с запасом над комиссиями.

Например, этим можно законтрить боковик, который был на BTCUSDT в Феврале 2024

  • 5–10 февраля, 73% нейтральных баров

  • 11–16 февраля, 63% нейтральных баров

  • 19–24 февраля, 75% нейтральных баров

  • 26–29 февраля, 69% нейтральных баров

Пример кода

import { sourceNode, outputNode } from '@backtest-kit/graph';
import { predict } from 'garch';
import { getCandles } from 'backtest-kit';

const CANDLES_FOR_GARCH = 300;
const GARCH_CONFIDENCE = 0.6827; // ±1σ

const garchSource = sourceNode(
  Cache.fn(
    async (symbol) => {
      const candles = await getCandles(symbol, '8h', CANDLES_FOR_GARCH);
      return predict(candles, '8h', null, GARCH_CONFIDENCE);
    },
    { interval: '8h', key: ([symbol]) => symbol },
  ),
);

const entrySignal = outputNode(
  async ([trend, volume]) => {
    // Пропускаем если модель не сошлась
    if (!volume.reliable) return null;

    // Проверяем что до границ канала достаточно места
    const upperDiff = percentDiff(trend.close, volume.upperPrice);
    const lowerDiff = percentDiff(trend.close, volume.lowerPrice);

    if (upperDiff < TAKE_PROFIT_PERCENT) return null;
    if (lowerDiff < STOP_LOSS_PERCENT) return null;

    // TP и SL по границам GARCH-канала
    const tp = trend.position === 'long' ? volume.upperPrice : volume.lowerPrice;
    const sl = trend.position === 'long' ? volume.lowerPrice : volume.upperPrice;

    return { position, priceOpen: trend.close, priceTakeProfit: tp, priceStopLoss: sl };
  },
  trendSource,
  garchSource,
);

GARCH здесь не генерирует направление. Он отвечает только на вопрос «достаточно ли ожидаемое движение». Направление приходит от другого источника (это может быть Pine Script через @backtest-kit/pinets или LLM через @backtest-kit/ollama)

Ключевые детали

  • Parkinson estimator для per-candle RV: (1/4ln2) · ln(H/L)² — в ~5× эффективнее squared returns

  • Log-normal bands: P·exp(±z·σ) — не линейное приближение, правильное маппирование в ценовое пространство

  • reliable: true когда: оптимизатор сошёлся + persistence < 0.999 + Ljung-Box p ≥ 0.05

  • Оптимизация: multi-start Nelder-Mead, GARCH — 4 рестарта, NoVaS — 7 (11-мерная задача)

  • 932 теста, включая ground-truth тест с синтетическими данными известной волатильности

Теги:
Всего голосов 3: ↑3 и ↓0+3
Комментарии0

Краткая версия Интервью Гвидо ван Роуссума с core-разработчиком Python Бреттом Кэнноном:

import textwrap


def print_bubble(text: str, name: str, side="left"):
    wrapped = textwrap.wrap(text, width=45)
    max_len = max(len(line) for line in wrapped)
    width = max_len + 2

    if side == "left":
        indent = ""
        tail = "╲|"
        bottom = indent + "╰" + "─" * (width - 1) + tail
    else:
        indent = " " * 52
        tail = "|/"
        bottom = indent + tail + "─" * (width - 1) + "╯"

    print(indent + "╭" + "─" * width + "╮")
    print(indent + name)
    for line in wrapped:
        print(indent + "│ " + line.ljust(max_len) + " │")
    print(bottom)


dialog = [
    ("left", "Гвидо:", "Как ты нашёл Python?"),
    ("right", "Бретт:", "Искал язык для ООП в 2000-м, попробовал Python — сразу зашло."),
    ("left", "Гвидо:", "И что дальше?"),
    ("right", "Бретт:", "Через Python Cookbook попал в сообщество, потом в python-dev."),
    ("left", "Гвидо:", "Быстро втянулся?"),
    ("right", "Бретт:", "Да, начал писать обзоры, отправлять патчи, добавил strptime, стал core-разработчиком в 2003."),
    ("left", "Гвидо:", "Каким было сообщество тогда?"),
    ("right", "Бретт:", "Небольшим, всё держалось на энтузиастах."),
    ("left", "Гвидо:", "А позже?"),
    ("right", "Бретт:", "Участвовал в переходе на Python 3, развитии стандартной библиотеки и управлении."),
    ("left", "Гвидо:", "Самый сложный момент?"),
    ("right", "Бретт:", "Твой уход и кризис управления помогли перейти к другой модели руководства."),
    ("left", "Гвидо:", "В итоге?"),
    ("right", "Бретт:", "Случайно попробовал Python и стал ключевым участником проекта."),
]

print("Нажимайте ENTER (или пробел) для следующего сообщения.\n")

for side, name, text in dialog:
    input()
    print_bubble(text, name, side)

print("\n Вы прочитали краткую версию. Подробнее читайте на https://habr.com/ru/articles/1017676/ \n")
Теги:
Всего голосов 5: ↑4 и ↓1+3
Комментарии1

Всем привет. Начал писать открытую книгу про архитектуру безопасных AI-агентов.

Делаю не обзор фреймворков и не коллекцию «магических демо», а практический инженерный reference: control plane, policy boundaries, tool gateway, memory, observability, evals, approval flows, governance и production-подход к агентным системам.

Уже выложил первые главы и каркас книги - https://agent-axiom.github.io/agent-arch

Репозиторий - https://github.com/agent-axiom/agent-arch

Буду очень рад критике по существу:

  • где архитектура спорная,

  • где не хватает важных разделов,

  • где формулировки слишком сырые,

  • что стоит добавить из практики эксплуатации и безопасности.

Если тема близка - вливайся: issues, comments, corrections, PRs, ссылки на сильные источники и контрпримеры из реальных production-систем.

Хочется сделать не просто набор заметок, а полезный community-driven reference для тех, кто строит надежных и безопасных AI-агентов.

Теги:
Всего голосов 6: ↑6 и ↓0+9
Комментарии0

Как я писал софт для фрагментного анализа ДНК

Всем привет! Меня зовут Александр Дориф, я химик, молекулярный генетик и сисадмин-инфраструктурщик в компании WebHostMost, многие знают меня по нику Father Nurgle.

Итак, на дворе осень 2022 года, я, на тот момент аспирант, разрабатываю способы диагностики болезней экспансии коротких повторов (хорея Хантингтона, синдром ломкой Х хромосомы...) или с изменением количества локусов в геноме (инсерции/делеции, анеуплоидии). Я активно использую капиллярный электрофорез на ABI 3500 Dx и фрагментный анализ с помощью GeneMapper 5. И это стало проблемой. Компов в лабе мало, денег тоже, лицензия GeneMapper одна (а дополнительная стоит больше 10к$), комп с GeneMapper часто занят, софт сам по себе прибит к венде и БД Oracle. А сам я работаю на ноуте, устаревшем ещё в конце нулевых. Да, есть NCBI OSIRIS, но для него нужен Wine, а это лишний слой абстракции, да и интерфейс у него переусложнён на мой взгляд, Fragman не поддерживал импорт файлов с 3500, fatools не развивались и автор не отвечал на сообщения.

Так я решил писать FragalyseQt. Я изначально видел его как кроссплатформенный и свободный софт, поэтому выбрал за основу Python (для него есть много полезного типа BioPython) и Qt для интерфейса. Учитывая то, что у меня не было опыта написания десктопных приложений, несколько дней я изучал мануалы, после чего тёмным вечером 6 октября 2022 выпустил самую первую версию FragalyseQt с номером 0.1 и кодовым именем «Huntington». Это была смотрелка файлов FSA, умеющая селективно скрывать выбранные каналы флуоресценции и экспортировать данные внутреннего анализа (для ABI 3500 и SeqStudio) в CSV.

В версии 0.2 «Friedreich», добавилась возможность независимого от прибора поиска и базового анализа пиков на электрофореграммах, я познакомился со SciPy и табличными возможностями Qt.

Версия 0.3 «DiGeorge» принесла возможность правки базовой линии и тонкой настройки поиска пиков. И... Я упёрся в фундаментальную проблему: определение размера фрагментов на электрофореграммах требовало теории приблизительных вычислений, которую нам в своё время не давали, давая математику по остаточному принципу. Без сайзинга, FragalyseQt будет всего лишь смотрелкой. Я начал ботать матан. Мозги плавились, времени не хватало, к аспирантуре добавились заботы о дочке, но я учил. Здесь же случилось знакомство с реальностью: не каждая декларация «мы поддерживаем формат ABIF» значит «мы поддерживаем ПОЛНУЮ спецификацию ABIF». Также пришлось столкнуться с древними вариантами ABIF, полученными до его стандартизации. Была работа в Okteta, написание парсеров, FragalaseQt стал читать и старый ABIF, и его криминалистическое подмножество — HID.

1 сентября 2024 вышла FragalyseQt 0.4 «Jeffreys» с сайзингом пиков методами степенных сплайнов, взвешенных степенных сплайнов и МНК. README стал подробнее, стремясь к полноценному мануалу. Позже добавил локальный и глобальный методы Саузерна. Софт стал реально аналитическим, с его помощью была опубликована работа на ESHG 2025 ( https://doi.org/10.13140/RG.2.2.14637.81123 ). Потом развитие опять затянулось — задержки ЗП в начале года по 3-4 месяца не способствовали размышлениям о чём-то, кроме выживания. В сентябре я перешёл в WebHostMost и, внезапно, у меня появились адекватные задачи, время и поддержка коллег. Была переработанна структура для соответствия PEP 517, добавлен гибкий интерфейс и экспериментальная поддержка импорта сырых данных российского Нанофор-05 (формат реверсил).

20 марта 2026 вышла FragalyseQt 0.5 «Southern» с импортом панелей GeneMapper, GeneMarker и NCBI OSIRIS, фильтрацией статтеров, экспортом в CODIS XML. Для скриншота мне было скучно использовать стандартные заглушки для данных (и ясно, что невозможно взять реальные данные дел), поэтому демо сделано как опознание тел после Резни в Зоне Высадки, Исстваан 5.

FragalyseQt 0.5 - экспорт данных после применения панелей в формат CODIS XML: выбираются вкладки с данными для экспорта, назначаются роли в рамках дела (жертва, персонал, подозреваемый, предполагаемый родитель и т.д.), заполняются данные лаборатории и экспортируются. Экспортированные данные могут быть внесены в совместимую с CODIS систему (например, SmallPond).
FragalyseQt 0.5 - экспорт данных после применения панелей в формат CODIS XML: выбираются вкладки с данными для экспорта, назначаются роли в рамках дела (жертва, персонал, подозреваемый, предполагаемый родитель и т.д.), заполняются данные лаборатории и экспортируются. Экспортированные данные могут быть внесены в совместимую с CODIS систему (например, SmallPond).
Теги:
Всего голосов 5: ↑5 и ↓0+5
Комментарии0