AI/ML Ready | Нейросети

Удаляем дубликаты и похожие изображения в датасете с помощью библиотеки ImageHash

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

Для вычисления перцептивных хешей и сравнения картинок установим специализированную библиотеку ImageHash и Pillow.

pip install imagehash pillow


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

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

from PIL import Image, ImageDraw
import imagehash

img1 = Image.new('RGB', (100, 100), color='white')
img2 = img1.resize((50, 50))

hash1 = imagehash.phash(img1)
hash2 = imagehash.phash(img2)
print("Difference:", hash1 - hash2)


Скрипт показал нулевую разницу хешей, подтвердив полное визуальное соответствие изображений разного размера.


# проверка (контрольный запуск проверки доступности модуля imagehash)
python3 -c "import imagehash; print('ImageHash Status:', hasattr(imagehash, 'phash'))"


Ожидаемый вывод: ImageHash Status: True


# cleanup (деинсталляция пакетов графической обработки)
pip uninstall imagehash pillow -y


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

👉 AI Ready | #практика

Создаем автономного AI-агента для выполнения внешних задач и вызова инструментов.

Обычные языковые модели ограничены только генерацией текста и не могут выполнять реальные действия в системе. AI-агенты связывают рассуждения LLM с внешними инструментами (Tool Calling), позволяя модели самостоятельно решать, какую функцию вызывать для выполнения цели. Мы создадим базового автономного агента на Python, который самостоятельно планирует действия и вызывает внешние инструменты.

Для работы автономного агента установим фреймворк LangChain и модуль интеграции с локальным движком Ollama.

pip install langchain-community langchain-ollama


Пакеты успешно загружены и готовы для сборки агентского конвейера.

Запустим Python-скрипт, в котором агент получает доступ к инструменту математических расчетов и автономно выполняет задачу.

from langchain_ollama import ChatOllama
from langchain_community.agent_toolkits.load_tools import load_tools
from langchain.agents import initialize_agent, AgentType

llm = ChatOllama(model="qwen2.5", temperature=0)
tools = load_tools(["llm-math"], llm=llm)
agent = initialize_agent(tools, llm, agent=AgentType.ZERO_SHOT_REACT_DESCRIPTION)
print(agent.run("Сколько будет 25 в степени 4, помноженное на 12?"))


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


# проверка (контрольный запуск проверки окружения для работы агентов)
python3 -c "import langchain; print('Agent Status:', hasattr(langchain, 'agents'))"


Ожидаемый вывод: Agent Status: True


# cleanup (деинсталляция установленных библиотек)
pip uninstall langchain-community langchain-ollama -y


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

👉 AI Ready | #ml

Оцениваем важность признаков в данных с помощью XGBoost за пару минут.

При обучении моделей машинного обучения важно понимать, какие именно данные влияют на итоговый результат, а какие создают лишний шум. Алгоритм XGBoost позволяет не только строить точные предсказания, но и автоматически вычислять метрику Feature Importance для каждой переменной. Мы сгенерируем синтетический датасет, обучим градиентный бустинг и выведем рейтинги значимости столбцов.

Для выполнения расчета установим библиотеки XGBoost и Scikit-learn для работы с алгоритмом и набором данных.

pip install xgboost scikit-learn


Пакеты успешно установлены в систему и готовы к импорту.

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

from sklearn.datasets import make_classification
import xgboost as xgb

X, y = make_classification(n_samples=500, n_features=5, random_state=42)
model = xgb.XGBClassifier(use_label_encoder=False, eval_metric='logloss').fit(X, y)

for idx, score in enumerate(model.feature_importances_):
print(f"Признак Feature_{idx}: {score:.4f}")


Модель рассчитала вес каждого входного параметра на основе разветвлений в деревьях решений.


# проверка (контрольный запуск вычисления важности признаков)
python3 -c "import xgboost as xgb, sklearn; print('XGBoost Status:', hasattr(xgb, 'XGBClassifier'))"


Ожидаемый вывод: XGBoost Status: True



# cleanup (удаление установленных зависимостей из окружения)
pip uninstall xgboost scikit-learn -y


Оценка Feature Importance помогает отсекать бесполезные признаки, уменьшая размер модели и ускоряя ее работу в продакшене. Для более глубокой интерпретации сложных моделей комбинируйте встроенный вес XGBoost с методом SHAP (SHapley Additive exPlanations).

👉 AI Ready | #практика

Анализируем сложные графовые связи с помощью классической сетевой библиотеки NetworkX.

Стандартные нейросети работают с таблицами и изображениями, но теряются при анализе сложных взаимосвязей между узлами. Графовые алгоритмы и нейросети (GNN) агрегируют признаки соседних вершин, выявляя скрытые паттерны в соцсетях, молекулах и транзакциях. Мы соберем базовый граф связей на Python и рассчитаем метрики центральности узлов для поиска ключевых элементов сети.

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

pip install networkx


Пакет успешно установлен и готов к работе с графами.

Запустим Python-скрипт, который создаст граф топологии и рассчитает метрику Eigenvector Centrality для поиска наиболее влиятельных узлов.

import networkx as nx

G = nx.karate_club_graph()
centrality = nx.eigenvector_centrality(G)
top_node = max(centrality, key=centrality.get)

print(f"Всего узлов: {G.number_of_nodes()} | Ребер: {G.number_of_edges()}")
print(f"Самый влиятельный узел: {top_node} с метрикой {centrality[top_node]:.4f}")


Алгоритм успешно определил ключевой узел графа на основе его связей с окружением.


# проверка (контрольный запуск импорта NetworkX и расчета графа)
python3 -c "import networkx as nx; print('GNN Pipeline Status:', nx.karate_club_graph().number_of_nodes())"


Ожидаемый вывод: GNN Pipeline Status: 34


# cleanup (удаление установленного пакета из системы)
pip uninstall networkx -y


Графовый подход незаменим в антифрод-системах, биоинформатике и рекомендательных сервисах. Для обучения полноценных глубоких GNN-моделей на миллионах узлов используйте специализированные фреймворки PyTorch Geometric (PyG) или DGL.

👉 AI Ready | #ml

Умное восстановление пропущенных значений в табличных данных через IterativeImputer.

Заполнение пропусков простым средним или медианой часто искажает взаимосвязи между признаками и снижает точность итоговой модели. Класс IterativeImputer из библиотеки scikit-learn использует многомерное восстановление, моделируя каждый признак с пропусками как функцию от других переменных. Мы задействуем этот подход на Python, чтобы автоматически восстановить пропущенные значения с учетом скрытых зависимостей.

Для начала установим библиотеку scikit-learn и пакет NumPy для работы с табличными массивами.

pip install scikit-learn numpy


Библиотеки успешно загружены и готовы к заполнению пропущенных данных.

Запустим Python-скрипт, который создаст матрицу с пропусками и восстановит их с помощью итеративной регрессии.

import numpy as np
from sklearn.experimental import enable_iterative_imputer
from sklearn.impute import IterativeImputer

X = np.array([[1, 2], [3, 6], [4, 8], [np.nan, 10], [6, np.nan]])
imputer = IterativeImputer(max_iter=10, random_state=42)
X_filled = imputer.fit_transform(X)

print(f"Восстановленная матрица без пропусков:\n{np.round(X_filled, 1)}")


Имтьютер проанализировал взаимосвязь столбцов и корректно восстановил отсутствующие значения.


# проверка (контрольный запуск импорта IterativeImputer из scikit-learn)
python3 -c "from sklearn.experimental import enable_iterative_imputer; from sklearn.impute import IterativeImputer; print('IterativeImputer: OK')"


Ожидаемый вывод: IterativeImputer: OK


# cleanup (удаление установленных библиотек)
pip uninstall scikit-learn numpy -y


IterativeImputer особенно эффективен на сложных датасетах, где показатели сильно зависят друг от друга (например, возраст, стаж и доход). Обязательно фиксируйте random_state для воспроизводимости результатов и сохраняйте обученный объект импьютера для валидационной выборки.

👉 AI Ready | #практика

Повышаем точность ответов LLM с помощью техники Self-Consistency.

При генерации ответа на сложную логическую или математическую задачу языковая модель может допустить случайную галлюцинацию в одном из шагов рассуждения. Техника Self-Consistency решает эту проблему путем параллельной генерации нескольких вариантов решения с последующим выбором наиболее часто встречающегося ответа. Мы напишем Python-скрипт, который опрашивает модель несколько раз и вычисляет итоговый консенсус голосованием большинства.

Для начала установим библиотеку OpenAI для работы с API языковых моделей.

pip install openai


Пакет успешно загружен и готов к отправке генеративных запросов.

Запустим Python-скрипт, реализующий сбор трех независимых решений и автоматический выбор мажоритарного ответа:

from collections import Counter
import os, openai

client = openai.OpenAI(api_key=os.getenv("OPENAI_API_KEY", "mock-key"))
prompt = "Ответь только числом: сколько будет 15 * 12?"
answers = []

for _ in range(3):
res = client.chat.completions.create(model="gpt-4o-mini", messages=[{"role": "user", "content": prompt}], temperature=0.7)
answers.append(res.choices[0].message.content.strip())

final_answer = Counter(answers).most_common(1)[0][0]
print(f"Все ответы: {answers} | Итоговый консенсус: {final_answer}")


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

# проверка (контрольный запуск импорта структуры Counter для голосования)
python3 -c "from collections import Counter; print('Self-Consistency Aggregator: OK' if Counter(['180', '180', '190']).most_common(1)[0][0] == '180' else 'FAIL')"


Ожидаемый вывод: Self-Consistency Aggregator: OK


# cleanup (удаление установленной библиотеки из системы)
pip uninstall openai -y


Метод Self-Consistency значительно снижает процент случайных ошибок в задачах на логику, генерацию кода и извлечение структурированных данных. Повышайте параметр temperature до 0.5–0.7, чтобы ответы модели отличались по траектории рассуждений, и используйте 3–5 прогонов для достижения оптимального баланса между точностью и затратами на API.

👉 AI Ready | #ml