ИИ для компьютерного зрения

Около 80% информации, которую получают люди, поступает через зрение.

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

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

Компьютерное зрение (CV) — это технология, позволяющая компьютерам понимать изображения.

От разблокировки по лицу на телефонах до распознавания дорожной обстановки в автономном вождении и до анализа поражений в медицинской визуализации — компьютерное зрение стало повсеместным.

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

Путь обучения: свёрточные нейронные сети → Vision Transformer → обнаружение объектов → сегментация изображений → диффузионные модели → CLIP → визуально-языковые модели. Каждый шаг сопровождается примерами кода, которые можно запустить.


Свёрточные нейронные сети (CNN)

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

Принципы операции свёртки

Основная идея свёртки заключается в следующем:использовать небольшое скользящее окно (ядро свёртки) для сканирования изображения и извлечения локальных признаков.。

Например, ядро 3×3 рассматривает 9 пикселей за раз, вычисляет их взвешенную сумму и выдаёт выходное значение.

Этот процесс повторяется; ядро скользит по изображению слева направо и сверху вниз, в конечном итоге создавая «карту признаков».

Пример

# ============================================
# Реализуйте простейшую операцию свёртки с помощью NumPy
# Продемонстрируйте, как свёртка извлекает краевые признаки
# ============================================

import numpy as np


def simple_convolution(image: np.ndarray, kernel: np.ndarray) -> np.ndarray:
    """
Реализуйте простейшую операцию 2D-свёртки (без дополнения и шага)

Параметры:
image: входное изображение (H, W), одноканальное в градациях серого
kernel: ядро свёртки (kH, kW)

Возвращает:
Карта признаков после свёртки
    """

    # Получаем размеры изображения и ядра
    img_h, img_w = image.shape
    kernel_h, kernel_w = kernel.shape

    # Вычисляем размер выходной карты признаков
    # Размер выхода = размер входа - размер ядра + 1
    out_h = img_h - kernel_h + 1
    out_w = img_w - kernel_w + 1

    # Инициализируем выходную карту признаков
    output = np.zeros((out_h, out_w))

    # Сдвигаем сверточное ядро для вычисления
    for i in range(out_h):
        for j in range(out_w):
            # Извлекаем локальную область изображения, соответствующую ядру
            region = image[i:i+kernel_h, j:j+kernel_w]
            # Перемножаем соответствующие элементы и суммируем (это операция свертки)
            output[i, j] = np.sum(region * kernel)

    return output


# Создаем простое тестовое изображение: белый квадрат в середине, черный вокруг него
# Форма: изображение в градациях серого 8×8
test_image = np.array([
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 1, 1, 1, 1, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0, 0, 0, 0],
])
print("Исходное изображение:")
print(test_image)

# Определить ядро обнаружения краёв (упрощённый оператор Собеля)
# Это ядро может обнаруживать вертикальные края
edge_kernel = np.array([
    [-1, 0, 1],
    [-2, 0, 2],
    [-1, 0, 1],
])

# Выполнить свёртку
feature_map = simple_convolution(test_image, edge_kernel)
print("\nКарта признаков после свёртки (обнаружены вертикальные края):")
print(np.round(feature_map, 2))

Ключ к операции свёртки:Параметры ядра свёртки обучаются, а не задаются вручную.。

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

Пулинг

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

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

Пример

# ============================================
# Реализовать операцию максимального пулинга
# ============================================

def max_pooling(feature_map: np.ndarray, pool_size: int = 2) -> np.ndarray:
    """
Реализовать операцию максимального пулинга

Параметры:
feature_map: входная карта признаков (H, W)
pool_size: размер окна пулинга, по умолчанию 2×2

Возвращает:
Карта признаков после пулинга
    """

    h, w = feature_map.shape
    # Вычислить размер выхода
    out_h = h // pool_size
    out_w = w // pool_size

    output = np.zeros((out_h, out_w))

    for i in range(out_h):
        for j in range(out_w):
            # Извлечь область окна пулинга
            region = feature_map[
                i*pool_size:(i+1)*pool_size,
                j*pool_size:(j+1)*pool_size
            ]
            # Взять максимальное значение
            output[i, j] = np.max(region)

    return output


# Выполнить пулинг, используя карту признаков из предыдущего шага
print("Карта признаков перед пулингом:")
print(feature_map)

pooled = max_pooling(feature_map, pool_size=2)
print("\n"Карта признаков после 2×2 max pooling:")
print(pooled)

Сравнение классических архитектур

В истории развития CNN есть несколько знаковых архитектур, каждая из которых представляет идеи проектирования разных периодов.

АрхитектураГодКлючевая инновацияХарактеристики
AlexNet2012Активация ReLU, Dropout, аугментация данныхПионер эпохи глубокого обучения, впервые значительно превзошедший традиционные методы на ImageNet.
VGG2014Единообразное использование маленьких свёрточных ядер 3×3Простая и элегантная структура, которую легко понять и реализовать
ResNet2015Остаточное соединение (Skip Connection)Решает проблему затухающего градиента в глубоких сетях, позволяя сетям иметь сотни слоёв.
EfficientNet2019Метод составного масштабированияОдновременно масштабирует глубину, ширину и разрешение при чрезвычайно высокой эффективности использования параметров.

Остаточное соединение (Skip Connection)

Ключевая инновация ResNet — остаточное соединение, которое решает проблему «чем глубже сеть, тем сложнее её обучать».

Цель обучения традиционного слоя сети — напрямую выучить отображение из входа x в выход y.

Цель обучения остаточной сети:выучить разность (остаток) между выходом y и входом x.。

Формула: y = F(x) + x, где F(x) — остаток, который нужно выучить.

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

Пример

# ============================================
# Реализуйте полный классификатор изображений на CNN с помощью PyTorch
# Включает свёртку, пулинг, остаточные соединения
# ============================================

import torch
import torch.nn as nn
import torch.nn.functional as F


class ResidualBlock(nn.Module):
    """Простой остаточный блок"""

    def __init__(self, in_channels: int, out_channels: int, stride: int = 1):
        super().__init__()
        # Первый свёрточный слой
        self.conv1 = nn.Conv2d(
            in_channels, out_channels,
            kernel_size=3, stride=stride, padding=1, bias=False
        )
        self.bn1 = nn.BatchNorm2d(out_channels)

        # Второй сверточный слой
        self.conv2 = nn.Conv2d(
            out_channels, out_channels,
            kernel_size=3, stride=1, padding=1, bias=False
        )
        self.bn2 = nn.BatchNorm2d(out_channels)

        # Сокращенное соединение (для согласования изменений размерности)
        self.shortcut = nn.Sequential()
        if stride != 1 or in_channels != out_channels:
            self.shortcut = nn.Sequential(
                nn.Conv2d(
                    in_channels, out_channels,
                    kernel_size=1, stride=stride, bias=False
                ),
                nn.BatchNorm2d(out_channels)
            )

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        # Основной путь: conv → BN → ReLU → conv → BN
        out = F.relu(self.bn1(self.conv1(x)))
        out = self.bn2(self.conv2(out))

        # Остаточное соединение: добавить вход (или вход после преобразования размерности)
        out += self.shortcut(x)

        # Финальный ReLU
        out = F.relu(out)
        return out


class SimpleCNN(nn.Module):
    """Простая CNN для классификации изображений (с остаточными соединениями)"""

    def __init__(self, num_classes: int = 10):
        super().__init__()
        # Начальный сверточный слой
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, stride=1, padding=1)
        self.bn1 = nn.BatchNorm2d(32)

        # Остаточный слой
        self.layer1 = ResidualBlock(32, 32)
        self.layer2 = ResidualBlock(32, 64, stride=2)
        self.layer3 = ResidualBlock(64, 64)

        # Глобальное усредняющее объединение
        self.global_pool = nn.AdaptiveAvgPool2d((1, 1))

        # Головка классификации
        self.fc = nn.Linear(64, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        # форма x: (batch_size, 3, 32, 32)
        x = F.relu(self.bn1(self.conv1(x)))

        x = self.layer1(x)  # (batch_size, 32, 32, 32)
        x = self.layer2(x)  # (batch_size, 64, 16, 16)
        x = self.layer3(x)  # (batch_size, 64, 16, 16)

        x = self.global_pool(x)  # (batch_size, 64, 1, 1)
        x = x.view(x.size(0), -1)  # (batch_size, 64)
        x = self.fc(x)  # (batch_size, num_classes)

        return x


# Создать модель и протестировать
model = SimpleCNN(num_classes=10)
print("Структура модели:")
print(model)

# Проверка прямого прохода
# Создайте фиктивный батч: 4 изображения, каждое 3×32×32 (RGB 32×32)
test_input = torch.randn(4, 3, 32, 32)
test_output = model(test_input)
print(f"\nФорма входных данных: {test_input.shape}")
print(f"Форма выхода: {test_output.shape} (batch_size, num_classes)")

Vision Transformer(ViT)

В 2020 году Google опубликовала статью "An Image is Worth 16x16 Words", перенеся архитектуру Transformer из языковой области в область компьютерного зрения.

Разбиение изображения на патчи (Patch Embedding)

Трансформеры обрабатывают данные последовательностей, но изображения — это 2D сеточные данные.

Решение ViT простое:Нарежьте изображение на маленькие патчи и рассматривайте каждый патч как слово。

Например, изображение 224×224, разбитое на патчи 16×16, даёт 14×14 = 196 патчей.

Каждый патч разворачивается в 1D-вектор и проецируется в эмбеддинг с помощью линейного слоя, который затем можно подать в Transformer.

Пример

# ============================================
# Реализация Patch Embedding (разбиение изображения на патчи)
# ============================================

class PatchEmbedding(nn.Module):
    """
Разбейте изображение на патчи и вычислите их эмбеддинги

Параметры:
img_size: размер входного изображения (квадратного)
patch_size: размер каждого патча (квадратного)
in_channels: количество входных каналов (3 для RGB)
embed_dim: размерность выходного эмбеддинга
    """


    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        embed_dim: int = 768
    ):
        super().__init__()
        self.img_size = img_size
        self.patch_size = patch_size
        # Вычислить количество патчей: (224/16)^2 = 14^2 = 196
        self.num_patches = (img_size // patch_size) ** 2

        # Использовать свёртку для реализации разбиения на патчи и встраивания
        # Это эквивалентно: нарезать патчи → развернуть → линейная проекция
        self.proj = nn.Conv2d(
            in_channels, embed_dim,
            kernel_size=patch_size, stride=patch_size
        )

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        # форма x: (batch_size, in_channels, img_size, img_size)
        x = self.proj(x)  # (batch_size, embed_dim, num_patches^0.5, num_patches^0.5)
        x = x.flatten(2)  # (batch_size, embed_dim, num_patches)
        x = x.transpose(1, 2)  # (batch_size, num_patches, embed_dim)
        return x


# Тестирование встраивания патчей
patch_embed = PatchEmbedding(img_size=224, patch_size=16, embed_dim=768)
test_image = torch.randn(1, 3, 224, 224)  # 1 RGB-изображение 224×224
patches = patch_embed(test_image)
print(f"Форма входного изображения: {test_image.shape}")
print(f"Форма последовательности патчей: {patches.shape} (batch_size, num_patches, embed_dim)")

Полная архитектура ViT

Полная архитектура ViT также требует добавления токена класса и позиционного кодирования.

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

Позиционное кодирование также обучаемое; оно сообщает модели, «где расположен каждый патч в изображении».

Пример

# ============================================
# Реализация упрощённого Vision Transformer
# ============================================

class MultiHeadAttention(nn.Module):
    """Самовнимание с несколькими головами"""

    def __init__(self, dim: int, num_heads: int):
        super().__init__()
        self.num_heads = num_heads
        self.head_dim = dim // num_heads
        assert self.head_dim * num_heads == dim, "Размерность должна делиться на количество голов"

        # Матрицы проекций Q, K, V
        self.qkv = nn.Linear(dim, dim * 3)
        # Выходная проекция
        self.proj = nn.Linear(dim, dim)

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        batch_size, seq_len, dim = x.shape

        # Вычислить Q, K, V
        qkv = self.qkv(x)  # (batch_size, seq_len, dim*3)
        qkv = qkv.reshape(
            batch_size, seq_len, 3, self.num_heads, self.head_dim
        )  # (batch_size, seq_len, 3, num_heads, head_dim)
        q, k, v = qkv.unbind(2)  # Форма каждого: (batch_size, seq_len, num_heads, head_dim)

        # Переставить размерности для вычисления внимания
        q = q.transpose(1, 2)  # (batch_size, num_heads, seq_len, head_dim)
        k = k.transpose(1, 2)
        v = v.transpose(1, 2)

        # Вычислить оценки внимания
        attention = q @ k.transpose(-2, -1) / (self.head_dim ** 0.5)
        attention = attention.softmax(dim=-1)

        # Агрегировать значения
        out = attention @ v  # (batch_size, num_heads, seq_len, head_dim)
        out = out.transpose(1, 2)  # (batch_size, seq_len, num_heads, head_dim)
        out = out.flatten(2)  # (batch_size, seq_len, dim)

        # Выходная проекция
        out = self.proj(out)
        return out


class TransformerBlock(nn.Module):
    """Блок Transformer"""

    def __init__(self, dim: int, num_heads: int, mlp_ratio: float = 4.0):
        super().__init__()
        self.norm1 = nn.LayerNorm(dim)
        self.attn = MultiHeadAttention(dim, num_heads)
        self.norm2 = nn.LayerNorm(dim)

        # Многослойный перцептрон
        mlp_hidden = int(dim * mlp_ratio)
        self.mlp = nn.Sequential(
            nn.Linear(dim, mlp_hidden),
            nn.GELU(),
            nn.Linear(mlp_hidden, dim)
        )

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        # Остаточное соединение 1
        x = x + self.attn(self.norm1(x))
        # Остаточное соединение 2
        x = x + self.mlp(self.norm2(x))
        return x


class SimpleViT(nn.Module):
    """Упрощённый Vision Transformer"""

    def __init__(
        self,
        img_size: int = 224,
        patch_size: int = 16,
        in_channels: int = 3,
        num_classes: int = 10,
        embed_dim: int = 192,
        depth: int = 6,
        num_heads: int = 6
    ):
        super().__init__()
        # Встраивание патчей
        self.patch_embed = PatchEmbedding(
            img_size, patch_size, in_channels, embed_dim
        )
        num_patches = self.patch_embed.num_patches

        # Токен класса
        self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))

        # Позиционное кодирование
        self.pos_embed = nn.Parameter(
            torch.zeros(1, num_patches + 1, embed_dim)
        )

        # Слои Transformer
        self.blocks = nn.ModuleList([
            TransformerBlock(embed_dim, num_heads)
            for _ in range(depth)
        ])

        # Финальный LayerNorm и классификационная голова
        self.norm = nn.LayerNorm(embed_dim)
        self.head = nn.Linear(embed_dim, num_classes)

    def forward(self, x: torch.Tensor) -> torch.Тензор:
        batch_size = x.shape[0]

        # Встраивание патчей
        x = self.patch_embed(x)  # (batch_size, num_patches, embed_dim)

        # Добавить токен класса
        cls_tokens = self.cls_token.expand(batch_size, -1, -1)
        x = torch.cat((cls_tokens, x), dim=1)  # (batch_size, 1+num_patches, embed_dim)

        # Добавить позиционное кодирование
        x = x + self.pos_embed

        # Пройти через слои Transformer
        for block in self.blocks:
            x = block(x)

        # Использовать только токен класса для классификации
        x = self.norm(x)
        cls_output = x[:, 0]  # Взять первую позицию (токен класса)
        x = self.head(cls_output)

        return x


# Создать модель ViT и протестировать
vit = SimpleViT(
    img_size=32,    # Используйте изображения меньшего размера для упрощения тестирования
    patch_size=8,   # Патч 8×8
    embed_dim=128,
    depth=4,
    num_heads=4,
    num_classes=10
)
print("Упрощённая архитектура ViT:")
print(vit)

test_input = torch.randn(2, 3, 32, 32)  # 2 изображения 32×32
test_output = vit(test_input)
print(f"\nФорма входных данных: {test_input.shape}")
print(f"Форма вывода: {test_output.shape}")

Сравнение CNN и ViT

У двух архитектур есть свои преимущества и недостатки; какую выбрать, зависит от вашего конкретного сценария.

ХарактеристикиCNNViT
Индуктивное смещениеСильное (локальность, инвариантность к сдвигу)Слабое (обучается на данных)
Требования к даннымРаботает с малым объемом данныхТребует больших объемов данных, чтобы проявить преимущества
Вычислительная эффективностьОбычно быстрее, зрелая аппаратная оптимизацияБольшое число параметров, вычислительно затратный
ИнтерпретируемостьЛегко визуализировать ядра свёрткиКарты внимания интерпретируемы, но всю модель интерпретировать сложнее
Дальние зависимостиТребуют нескольких слоёв для установленияЕстественно поддерживает глобальное рецептивное поле
Применимые сценарииОграниченные данные, высокие требования к реальному времениБольшие наборы данных, сложные визуальные задачи

Практическое правило: используйте CNN (ResNet, EfficientNet), когда данных мало; рассмотрите ViT, когда объём данных достигает миллионов или больше. Существуют также гибридные архитектуры (например, ConvNeXt), сочетающие преимущества обоих подходов.


Обнаружение объектов

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

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

Двухэтапное обнаружение: серия R-CNN

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

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

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

Эволюция семейства R-CNN:

МодельКлючевые улучшенияСкорость
R-CNNЗаменяет традиционные признаки на CNNМедленно (десятки секунд на изображение)
Fast R-CNNROI Pooling, совместное вычисление признаковСредне (несколько секунд на изображение)
Faster R-CNNRPN (Region Proposal Network)Быстро (сотни миллисекунд на изображение)
Mask R-CNNДобавляет ветвь сегментацииСредняя

Одноэтапное обнаружение: серия YOLO

Идея одноэтапного обнаружения:Напрямую выполнять плотное предсказание по изображению без отдельного создания регионов-кандидатов。

YOLO (You Only Look Once) — представитель одноэтапного обнаружения, чрезвычайно быстрый и подходящий для приложений реального времени.

YOLO делит изображение на сетку S×S, и каждая ячейка сетки отвечает за предсказание объектов, центр которых попадает в эту ячейку.

Каждая ячейка сетки предсказывает: B ограничивающих рамок (с уверенностью) и вероятности для C классов.

Сквозное обнаружение: DETR

DETR (DEtection TRansformer) — новая парадигма, предложенная Facebook AI, использующая Transformer для преобразования обнаружения объектов в задачу прямого предсказания последовательности.

Его самая большая особенность: не требуется подавление не-максимумов (NMS), не нужны якорные боксы (Anchor), выход является окончательным результатом.

Практическое занятие: обнаружение объектов YOLOv11

Теперь мы используем Ultralytics YOLOv11, чтобы создать полный пример обнаружения объектов.

Пример

# ============================================
# Практическое занятие по обнаружению объектов YOLOv11
# Включает загрузку модели, обнаружение, визуализацию
# ============================================

import torch
import numpy as np
from PIL import Image, ImageDraw, ImageFont
import matplotlib.pyplot as plt


class SimpleYOLO:
    """Упрощённая демонстрация YOLO (с использованием предобученной модели)"""

    def __init__(self, model_name: str = "yolo11n.pt"):
        """
Инициализация модели YOLO

Параметры:
model_name: имя модели, yolo11n.pt (nano, small), yolo11s.pt (small) и т. д.
        """

        self.model_name = model_name
        self.model = None
        # 80 категорий набора данных COCO
        self.coco_names = [
            'человек', 'велосипед', 'автомобиль', 'мотоцикл', 'самолёт', 'автобус',
            'поезд', 'грузовик', 'лодка', 'светофор', 'пожарный гидрант',
            'знак стоп', 'паркомат', 'скамейка', 'птица', 'кошка', 'собака',
            'лошадь', 'овца', 'корова', 'слон', 'медведь', 'зебра', 'жираф',
            'рюкзак', 'зонт', 'сумочка', 'галстук', 'чемодан', 'фрисби',
            'лыжи', 'сноуборд', 'спортивный мяч', 'воздушный змей', 'бейсбольная бита',
            'бейсбольная перчатка', 'скейтборд', 'доска для серфинга', 'теннисная ракетка',
            'бутылка', 'бокал для вина', 'чашка', 'вилка', 'нож', 'ложка', 'миска',
            'банан', 'яблоко', 'бутерброд', 'апельсин', 'брокколи', 'морковь',
            'хот-дог', 'пицца', 'пончик', 'торт', 'стул', 'диван',
            'комнатное растение', 'кровать', 'обеденный стол', 'унитаз', 'телевизор', 'ноутбук',
            'мышь', 'пульт', 'клавиатура', 'мобильный телефон', 'microwave', 'oven',
            'toaster', 'sink', 'refrigerator', 'book', 'clock', 'vase',
            'scissors', 'teddy bear', 'hair drier', 'toothbrush'
        ]
        # Цвет для каждой категории
        self.colors = np.random.randint(0, 255, (80, 3))

    def load_model(self):
        """Загрузить предварительно обученную модель (здесь используется имитационная реализация для демонстрации концепции)"""
        print(f"Загрузка модели {self.model_name}...")
        print("Примечание: при фактическом использовании установите ultralytics и вызовите:")
        print(" from ultralytics import YOLO")
        print(" model = YOLO('yolo11n.pt')")
        self.model = "pretrained_model_loaded"
        print("Модель успешно загружена!")
        return self

    def predict_dummy(self, image: np.ndarray) -> list:
        """
Имитированные результаты обнаружения (для демонстрации)
При реальном использовании вызовите model(image)

Возвращает:
Список результатов обнаружения, каждый элемент — словарь:
            {'bbox': [x1, y1, x2, y2], 'class_id': int, 'score': float, 'class_name': str}
        """

        # Здесь мы имитируем обнаружение нескольких объектов
        h, w = image.shape[:2]
        dummy_results = [
            {'bbox': [w*0.1, h*0.2, w*0.3, h*0.6], 'class_id': 0, 'score': 0.92, 'class_name': 'person'},
            {'bbox': [w*0.35, h*0.4, w*0.7, h*0.8], 'class_id': 2, 'score': 0.85, 'class_name': 'car'},
            {'bbox': [w*0.75, h*0.3, w*0.9, h*0.55], 'class_id': 16, 'score': 0.78, 'class_name': 'dog'},
        ]
        return dummy_results

    def visualize(self, image: np.ndarray, results: list) -> np.ndarray:
        """
Нарисовать рамки обнаружения и метки на изображении

Параметры:
image: исходное изображение (H, W, 3)
results: список результатов обнаружения

Возвращает:
Аннотированное изображение
        """

        if isinstance(image, np.ndarray):
            image = Image.fromarray(image)

        draw = ImageDraw.Draw(image)

        for result in results:
            bbox = result['bbox']
            class_id = result['class_id']
            score = result['score']
            class_name = result['class_name']

            color = tuple(self.colors[class_id % 80].tolist())

            # Нарисовать рамку
            draw.rectangle(bbox, outline=color, width=3)

            # Фон метки
            label = f"{class_name} {score:.2f}"
            try:
                font = ImageFont.truetype("arial.ttf", 16)
            except:
                font = ImageFont.load_default()

            # Вычислить размер текста
            bbox_label = draw.textbbox((0, 0), label, font=font)
            text_w = bbox_label[2] - bbox_label[0]
            text_h = bbox_label[3] - bbox_label[1]

            # Нарисовать фон метки
            label_bg = [bbox[0], bbox[1]-text_h-5, bbox[0]+text_w+5, bbox[1]]
            draw.rectangle(label_bg, fill=color)

            # Нарисовать текст
            draw.text((bbox[0]+2, bbox[1]-text_h-3), label, fill=(255,255,255), font=font)

        return np.array(image)


# Создать имитационное изображение (для демонстрации)
def create_test_image() -> np.ndarray:
    """Создать тестовое изображение"""
    h, w = 480, 640
    image = np.zeros((h, w, 3), dtype=np.uint8)
    # Градиентный фон
    image[:, :, 0] = np.linspace(100, 200, w)[np.newaxis, :]
    image[:, :, 1] = np.linspace(150, 100, h)[:, np.newaxis]
    image[:, :, 2] = 180
    return image


# Демонстрация процесса обнаружения YOLO
print("=" * 60)
print("ПРИМЕР: Демонстрация обнаружения объектов YOLOv11")
print("=" * 60)

# Инициализация
detector = SimpleYOLO().load_model()

# Создание тестового изображения
test_image = create_test_image()
print(f"\nРазмер входного изображения: {test_image.shape}")

# Имитация обнаружения
results = detector.predict_dummy(test_image)
print(f"\n"Обнаружено {len(results)} объектов:")
for i, r in enumerate(results, 1):
    print(f" {i}. {r['class_name']} (Уверенность: {r['score']:.2f})")

# Визуализация
visualized = detector.visualize(test_image, results)
print(f"\nВизуализация завершена, размер выходного изображения: {visualized.shape}")


# ============================================
# Фактический код для использования YOLOv11 (требуется установить ultralytics)
# ============================================
print("\n" + "=" * 60)
print("Пример кода для фактического использования YOLOv11:")
print("=" * 60)
print("""
# Установка: pip install ultralytics

from ultralytics import YOLO

# 1. Загрузить модель
model = YOLO('yolo11n.pt') # Вы также можете использовать 'yolo11s.pt', 'yolo11m.pt' и т. д.

# 2. Предсказание
results = model('test_image.jpg') # Может быть путём к изображению, видео или 0 (веб-камера)

# 3. Обработка результатов
for result in results:
# Рамки обнаружения
    boxes = result.boxes
# Маски сегментации (при использовании модели сегментации)
    masks = result.masks
# Показать результаты
    result.show()
# Сохранить результаты
    result.save('result.jpg')

# 4. Обучение (необязательно)
# model.train(data='coco128.yaml', epochs=100, imgsz=640)
"""
)

Сегментация изображений

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

Семантическая сегментация vs сегментация экземпляров

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

ЗадачаЦельПримерРепрезентативные модели
Семантическая сегментацияКлассифицировать каждый пиксель (независимо от экземпляра)Пометить всех людей красным, все автомобили синимFCN、U-Net、DeepLab
Сегментация экземпляровКлассифицировать каждый пиксель и различать разные экземплярыОтметьте человека 1 красным, человека 2 — оранжевымMask R-CNN、YOLOv8-Seg
Панорамная сегментацияСемантическая + экземплярная, унифицированное представлениеОдновременно размечать все 'вещи' и 'фон'Panoptic FPN、MaskFormer

Классический пример: предположим, есть два человека и две собаки.

Семантическая сегментация говорит: здесь есть 'люди' и 'собаки' (только категории, а не количество).

Экземплярная сегментация говорит: здесь есть 'человек 1', 'человек 2', 'собака 1', 'собака 2' (каждый экземпляр отличается).

Segment Anything Model(SAM)

В 2023 году Meta AI выпустила SAM (Segment Anything Model), что превратило сегментацию в интерактивную задачу, управляемую промптами.

Входными данными для SAM могут быть: точка, рамка, фрагмент текста или грубая маска.

Выход SAM: точная маска сегментации соответствующего объекта.

Философия дизайна SAM:Поддержка промптов, обобщаемость, zero-shot。

Пример

# ============================================
# Демонстрация концепции сегментации SAM
# Показать, как выполнять сегментацию с помощью промптов, таких как точки, рамки и т. д.
# ============================================

class SimpleSAM:
    """Упрощённая демонстрация концепции SAM"""

    def __init__(self):
        self.image_embedding = None
        print("Инициализация демонстрации концепции SAM")

    def set_image(self, image: np.ndarray):
        """Закодировать изображение (только один раз)"""
        print("Кодирование изображения в эмбеддинг...")
        self.image_embedding = "image_encoded"
        return self

    def predict_from_point(self, point: tuple, point_label: int = 1):
        """
Сегментация по точке

Параметры:
point: координаты (x, y)
point_label: 1 для переднего плана, 0 для фона
        """

        print(f"Сегментация по точке {point} ({'передний план' if point_label == 1 else 'фон'})")
        return "mask_from_point"

    def predict_from_box(self, : tuple):
        """Сегментация по ограничивающей рамке"""
        x1, y1, x2, y2 = ⟦0⟧
        print(f"Сегментация по рамке [{x1}, {y1}, {x2}, {y2}]")
        return "mask_from_box"

    def predict_from_points(self, points: list, labels: list):
        """Сегментация по нескольким точкам"""
        print(f"Сегментация по {len(points)} точкам")
        return "mask_from_points"


# Демонстрация рабочего процесса использования SAM
print("=" * 60)
print("ПРИМЕР: Демонстрация концепции сегментации SAM")
print("=" * 60)

sam = SimpleSAM()

# 1. Подготовить изображение (закодировать один раз)
test_img = create_test_image()
sam.set_image(test_img)

# 2. Сегментировать с разными подсказками
print()
mask1 = sam.predict_from_point((100, 200), point_label=1)

print()
mask2 = sam.predict_from_box((50, 50, 200, 300))

print()
mask3 = sam.predict_from_points([(100, 100), (150, 150)], [1, 1])


# ============================================
# Пример кода для реального использования SAM
# ============================================
print("\n" + "=" * 60)
print("Пример кода для реального использования SAM:")
print("=" * 60)
print("""
# Установка: pip install segment-anything torch torchvision opencv-python

import cv2
import numpy as np
from segment_anything import sam_model_registry, SamPredictor

# 1. Загрузить модель
# Скачать чекпоинт: https://dl.fbaipublicfiles.com/segment_anything/sam_vit_h_4b8939.pth
sam = sam_model_registry["vit_h"](checkpoint="sam_vit_h_4b8939.pth")
sam.to(device="cuda")
predictor = SamPredictor(sam)

# 2. Подготовка изображения
image = cv2.imread("test_image.jpg")
image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)
predictor.set_image(image)

# 3. Сегментация с точечными подсказками
input_point = np.array([[300, 250]]) # координаты точки-подсказки
input_label = np.array([1]) # 1 = передний план, 0 = фон

masks, scores, logits = predictor.predict(
    point_coords=input_point,
    point_labels=input_label,
    multimask_output=True
)

# 4. Визуализация результатов
for i, mask in enumerate(masks):
    color = np.array([30, 144, 255])
    h, w = mask.shape
    mask_image = mask.reshape(h, w, 1) * color.reshape(1, 1, -1)
    cv2.imwrite(f"mask_{i}.jpg", mask_image)
"""
)

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

Сегментация изображений — ключевая технология во многих промышленных приложениях:

ПолеСценарий примененияТип задачи
Медицинская визуализацияСегментация опухолей, измерение органовСемантическая сегментация
Автономное вождениеОбнаружение зоны движения и линий полосыСемантическая сегментация
Изображения дистанционного зондированияКлассификация земного покрова, извлечение зданийСемантическая сегментация
Интеллектуальное производствоОбнаружение дефектов, измерение деталейСегментация экземпляров
Редактирование видеоМатирование человека, замена фонаСегментация экземпляров

Диффузионные модели

Диффузионные модели — ключевая технология для генерации изображений с помощью ИИ; Stable Diffusion, DALL-E 3 и Midjourney основаны на ней.

Прямой процесс диффузии (добавление шума)

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

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

Пример

# ============================================
# Продемонстрировать прямой процесс диффузионной модели (добавление шума)
# ============================================

import numpy as np
import matplotlib.pyplot as plt


class ForwardDiffusion:
    """Демонстрация прямого процесса диффузии"""

    def __init__(self, num_timesteps: int = 1000):
        self.num_timesteps = num_timesteps

        # Задать расписание beta (линейно возрастающее от beta_start до beta_end)
        self.beta_start = 0.0001
        self.beta_end = 0.02
        self.betas = np.linspace(self.beta_start, self.beta_end, num_timesteps)

        # Вычислить alpha и alpha_bar
        self.alphas = 1.0 - self.betas
        self.alphas_bar = np.cumprod(self.alphas)

    def q_sample(self, x0: np.ndarray, t: int) -> tuple:
        """
Вычислить xt в момент времени t напрямую из x0

Параметры:
x0: исходное изображение (H, W, 3)
t: шаг времени (0 <= t < num_timesteps)

Возвращает:
xt: изображение в момент времени t
noise: добавленный шум
        """

        sqrt_alpha_bar_t = np.sqrt(self.alphas_bar[t])
        sqrt_one_minus_alpha_bar_t = np.sqrt(1 - self.alphas_bar[t])

        # Сгенерировать случайный шум той же формы
        noise = np.random.randn(*x0.shape)

        # Вычислить xt за один шаг
        xt = sqrt_alpha_bar_t * x0 + sqrt_one_minus_alpha_bar_t * noise

        return xt, noise


# Создать простое тестовое изображение: яркий круг в центре
def create_diffusion_test_image():
    h, w = 64, 64
    x = np.linspace(-1, 1, w)
    y = np.linspace(-1, 1, h)
    xx, yy = np.meshgrid(x, y)
    r = np.sqrt(xx**2 + yy**2)
    image = np.exp(-r**2 / 0.1)  # Яркий круг с гауссовым распределением
    image = (image - image.min()) / (image.max() - image.min())  # Нормализовать к [0, 1]
    image = np.stack([image, image*0.8, image*0.5], axis=-1)  # Преобразовать в 3 канала
    return image


print("=" * 60)
print("ПРИМЕР Демонстрация прямого процесса диффузии")
print("=" * 60)

# Инициализировать процесс диффузии
diffusion = ForwardDiffusion(num_timesteps=1000)

# Создание тестового изображения
x0 = create_diffusion_test_image()
print(f"Форма исходного изображения: {x0.shape}")

# Отобразить результаты добавления шума на разных временных шагах
timesteps_to_show = [0, 100, 200, 300, 500, 1000]

print("\nУровень шума на разных временных шагах: ")
for t in timesteps_to_show:
    if t < 1000:
        xt, noise = diffusion.q_sample(x0, t)
        alpha_bar = diffusion.alphas_bar[t]
        print(f" t={t:4d}: alpha_bar={alpha_bar:.4f}, SNR={alpha_bar/(1-alpha_bar):.4f}")
    else:
        print(f" t={t:4d}: чистый шум")

print("\nОсновная формула прямого процесса диффузии: ")
print(" q(x_t | x_0) = N(x_t; sqrt(alpha_bar_t) * x0, (1 - alpha_bar_t) * I)")
print("\nЭта формула позволяет вычислить x_t в любой момент времени t из x0 за один шаг, без пошаговой итерации!)

Обратный процесс удаления шума

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

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

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

Архитектура U-Net

В основе диффузионной модели лежит сеть U-Net, форма которой напоминает букву "U": слева — даунсэмплинг и сжатие, справа — апсэмплинг и восстановление.

Ключ к U-Net — это skip-соединение, которое напрямую передаёт признаки со слоёв даунсэмплинга на соответствующие слои апсэмплинга, сохраняя детальную информацию.

Сравнение сэмплирования DDPM и DDIM

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

СэмплерПолное названиеШагиХарактеристики
DDPMВероятностные модели диффузии с шумоподавлением1000Оригинальный метод, хорошее качество, но медленный
DDIMНеявные модели диффузии с шумоподавлением50-100Детерминированное сэмплирование, быстро
LMSЛинейный многошаговый метод30-50Быстро, хорошее качество
DPM-SolverDPM-Solver10-20Сверхбыстрый, достигает хороших результатов всего за несколько шагов

Текущая Stable Diffusion по умолчанию использует DPM-Solver++, обычно достигая высококачественных результатов за 20-30 шагов, в десятки раз быстрее исходного DDPM.

Архитектура Stable Diffusion

Stable Diffusion работает не напрямую в пиксельном пространстве, а в латентном пространстве (Latent Space), что делает её быстрее и эффективнее.

Полная Stable Diffusion состоит из трёх частей:

1. VAE (вариационный автоэнкодер): сжимает изображения в латентные векторы или восстанавливает изображения из латентных векторов.

2. UNet: основная сеть шумоподавления, принимает латентные векторы, шаги времени и эмбеддинги промпта и предсказывает шум.

3. Text Encoder (CLIP): преобразует текстовые промпты в эмбеддинги, сообщая модели, что генерировать.

Пример

# ============================================
# Демонстрация концепции Stable Diffusion
# Показать полный конвейер генерации
# ============================================

class SimpleStableDiffusion:
    """Упрощённая демонстрация концепции Stable Diffusion"""

    def __init__(self):
        print("Инициализация демонстрации концепции Stable Diffusion")

    def encode_text(self, prompt: str):
        """Кодирование текстового запроса"""
        print(f"Кодирование запроса: '{prompt}'")
        return "text_embedding"

    def encode_image(self, image: np.ndarray):
        """VAE кодирует изображение в латентное пространство"""
        print(Кодирование изображения в латентное пространство (кодировщик VAE))
        return "latent_code"

    def decode_latent(self, latent: str):
        VAE декодирует изображение из латентного пространства
        print(Декодирование изображения из латентного пространства (декодер VAE))
        return "decoded_image"

    def denoise_step(self, latent: str, text_embedding: str, t: int):
        Одношаговое шумоподавление
        print(fШаг шумоподавления t={t})
        return "denoised_latent"

    def generate(self, prompt: str, num_inference_steps: int = 50):
        Полный конвейер генерации
        print("=" * 60)
        print(fНачало генерации: '{prompt}')
        print("=" * 60)

        # 1. Кодирование текста
        text_emb = self.encode_text(prompt)

        # 2. Начать со случайного шума
        print("\nИнициализация случайного шума...)
        latent = "random_noise"

        # 3. Пошаговое удаление шума
        print(f"\nЗапуск цикла удаления шума ({num_inference_steps} шагов):)
        for t in reversed(range(num_inference_steps)):
            latent = self.denoise_step(latent, text_emb, t)

        # 4. Декодировать для получения изображения
        print("\nДекодирование латентного вектора в изображение...)
        image = self.decode_latent(latent)

        print("\nГенерация завершена!)
        return image


# Демонстрация пайплайна генерации
sd = SimpleStableDiffusion()
image = sd.generate(
    prompt=Милый рыжий кот в саду,
    num_inference_steps=20
)


# ============================================
# Пример реального кода с использованием Stable Diffusion
# ============================================
print("\n" + "=" * 60)
print(Пример реального кода с использованием Stable Diffusion:)
print("=" * 60)
print("""
# Установка: pip install diffusers transformers accelerate torch

from diffusers import StableDiffusionPipeline
import torch

# 1. Загрузите модель
model_id = "runwayml/stable-diffusion-v1-5"
pipe = StableDiffusionPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
)
pipe = pipe.to("cuda")

# 2. Текст в изображение
prompt = "милый рыжий кот в саду"
image = pipe(prompt).images[0]

# 3. Сохраните результат
image.save("cat_garden.png")

# 4. Изображение-в-изображение
from diffusers import StableDiffusionImg2ImgPipeline
from PIL import Image

img_pipe = StableDiffusionImg2ImgPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
).to("cuda")

init_image = Image.open("input.jpg").convert("RGB")
init_image = init_image.resize((512, 512))

image = img_pipe(
    prompt="сделай так, чтобы это выглядело как картина",
    image=init_image,
strength=0.75 # степень вариации
).images[0]
image.save("painted.png")

# 5. Inpainting (локальная модификация)
from diffusers import StableDiffusionInpaintPipeline

inpaint_pipe = StableDiffusionInpaintPipeline.from_pretrained(
    model_id,
    torch_dtype=torch.float16
).to("cuda")

image = inpaint_pipe(
    prompt="надень шляпу на кота",
    image=init_image,
mask_image=mask_image # изображение-маска, белые области — это части, которые нужно изменить
).images[0]
"""
)

CLIP: Основы мультимодального выравнивания

CLIP (Contrastive Language-Image Pre-training) — работа, опубликованная OpenAI в 2021 году, которая впервые по-настоящему сопоставила текст и изображения в одном векторном пространстве.

Принципы контрастивного обучения

Метод обучения CLIP — контрастивное обучение:Сделать так, чтобы правильные пары изображение-текст имели высокое сходство, а неправильные — низкое.。

Во время обучения один батч содержит N изображений и N текстовых описаний (во взаимно однозначном соответствии), образуя N×N возможных пар изображение-текст.

На диагонали расположены совпадающие положительные примеры, а остальные — несовпадающие отрицательные примеры.

Цель обучения: максимизировать сходство положительных примеров и минимизировать сходство отрицательных примеров.

Обучение выравниванию изображений и текста

CLIP состоит из двух энкодеров:

  • 1. Кодировщик изображений: кодирует изображение в вектор (может быть ResNet или ViT).

  • 2. Текстовый кодировщик: кодирует текст в векторы (Transformer).

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

Пример

# ============================================
# Демонстрация концепции CLIP: контрастивное обучение и выравнивание изображения и текста
# ============================================

import torch
import torch.nn.functional as F


class SimpleCLIP:
    """Упрощённая демонстрация концепции CLIP"""

    def __init__(self, embed_dim: int = 512):
        self.embed_dim = embed_dim
        # Простая симуляция: не настоящее кодирование, просто случайная проекция
        print("Инициализация демонстрации концепции CLIP")
        print(f"Размерность эмбеддинга: {embed_dim}")

    def encode_image(self, image: str) -> torch.Тензор:
        """Имитация кодирования изображения"""
        # На практике это был бы Vision Transformer или ResNet
        return torch.randn(1, self.embed_dim)

    def encode_text(self, text: str) -> torch.Тензор:
        """Имитация кодирования текста"""
        # На практике это был бы Text Transformer
        return torch.randn(1, self.embed_dim)

    def compute_similarity(self, image_emb: torch.Tensor, text_emb: torch.Tensor) -> float:
        """Вычислить косинусное сходство"""
        image_emb = F.normalize(image_emb, dim=-1)
        text_emb = F.normalize(text_emb, dim=-1)
        return (image_emb @ text_emb.T).item()


# Демонстрация процесса инференса CLIP
print("=" * 60)
print("ПРИМЕР демонстрации zero-shot классификации CLIP")
print("=" * 60)

clip = SimpleCLIP(embed_dim=512)

# Предположим, есть изображение
print("\n1. Кодирование изображения...")
image_emb = clip.encode_image("Фотография кошки")

# Предположим, есть несколько категорий-кандидатов
candidates = ["Фотография собаки", "Фотография кошки", "Автомобиль", "Человек"]
print(f"\n2. Кодирование текстов кандидатов: {candidates}")

# Вычисление сходства
print("\n3. Вычисление сходства изображения и текста:")
for text in candidates:
    text_emb = clip.encode_text(text)
    sim = clip.compute_similarity(image_emb, text_emb)
    print(f" '{text}' → сходство: {sim:.3f}")

print("\n(На практике 'a photo of a cat' будет иметь наибольшее сходство)")


# ============================================
# Реальный пример использования CLIP
# ============================================
print("\n" + "=" * 60)
print("Реальный пример использования CLIP:")
print("=" * 60)
print("""
# Установка: pip install clip torch torchvision

import clip
import torch
from PIL import Image

# 1. Загрузите модель
device = "cuda" if torch.cuda.is_available() else "cpu"
model, preprocess = clip.load("ViT-B/32", device=device)

# 2. Подготовка изображения
image = preprocess(Image.open("cat.jpg")).unsqueeze(0).to(device)

# 3. Подготовка текста
text = clip.tokenize([
    "фотография собаки",
    "фотография кошки",
    "фотография машины",
    "фотография человека"
]).to(device)

# 4. Инференс
with torch.no_grad():
    image_features = model.encode_image(image)
    text_features = model.encode_text(text)

    logits_per_image, logits_per_text = model(image, text)
    probs = logits_per_image.softmax(dim=-1).cpu().numpy()

# 5. Вывод результатов
print("Вероятности предсказания:")
for i, p in enumerate(probs[0]):
    print(f" {i+1}. {p:.2%}")
"""
)

Возможность Zero-Shot классификации

Самая впечатляющая возможность CLIP — это Zero-Shot классификация:Он может классифицировать напрямую без обучения на целевом наборе данных。

Модели, обученные на традиционном ImageNet, могут классифицировать только 1000 классов ImageNet; добавление новых классов требует повторного обучения.

CLIP может использовать произвольный текст для описания категорий, например: "фотография кошки", "оранжевый кот сидит на траве", "набросок кошки".

Значимость CLIP не только в Zero-Shot классификации, но и в том, что он создаёт общий визуально-языковой интерфейс; многие последующие модели (такие как Stable Diffusion, визуально-языковые модели) построены на его основе.


Визуально-языковые модели (VLM)

Визуально-языковая модель (VLM) объединяет понимание изображений и генерацию языка, позволяя модели «смотреть на картинки и говорить».

Архитектура LLaVA

LLaVA (Large Language and Vision Assistant) — это VLM с открытым исходным кодом. Её дизайн прост и понятен, что делает её очень подходящей для начинающих.

Архитектура LLaVA делится на три части:

  • 1. Визуальный кодировщик: визуальный кодировщик CLIP, который преобразует изображения в эмбеддинги.

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

  • 3. LLM: большая языковая модель (например, Vicuna, LLaMA), которая получает объединённый вход изображения и текста и генерирует ответы.

Обучение делится на два этапа:

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

  • 2. Этап дообучения по инструкциям: вся модель обучается на наборах данных визуальных инструкций (например, LLaVA-Instruct).

Связь между визуальным кодировщиком и LLM

Ключ к соединению зрения и языка заключается в следующем:представление изображений в виде последовательностей токенов, которые могут понимать языковые модели。

Существуют несколько распространённых способов соединения:

МетодХарактеристикиТипичные модели
Специальный токенИспользовать один токен [IMG] для представления всего изображенияРанние модели
Конкатенация последовательностейНапрямую конкатенировать эмбеддинги патчей изображения перед текстомLLaVA、GPT-4V
Перекрёстное вниманиеДобавить перекрёстное внимание к визуальным признакам в LLMBLIP-2、Flamingo

Пример

# ============================================
# Демонстрация концепции визуально-языковой модели (VLM)
# Показать, как конкатенировать визуальные и языковые входные данные
# ============================================

class SimpleVLM:
    """Упрощённая визуально-языковая модель"""

    def __init__(self, vocab_size: int = 50000, hidden_size: int = 768):
        self.vocab_size = vocab_size
        self.hidden_size = hidden_size
        print("Инициализация упрощённой VLM")

    def encode_vision(self, image: str) -> torch.Тензор:
        """Закодировать изображение как последовательность"""
        # Предполагаем, что имеется 256 визуальных токенов
        return torch.randn(1, 256, self.hidden_size)

    def encode_text(self, text: str) -> torch.Тензор:
        """Закодировать текст как последовательность"""
        # Предположим, что текст содержит 16 токенов
        return torch.randn(1, 16, self.hidden_size)

    def generate(self, image: str, question: str) -> str:
        """Конкатенация изображения и текста генерирует ответ"""
        print("=" * 60)
        print(f"Вопрос: {question}")
        print("=" * 60)

        # 1. Кодирование изображения и текста
        print("\n1. Кодирование изображения...)
        vision_emb = self.encode_vision(image)

        print("2. Кодирование текста...")
        text_emb = self.encode_text(question)

        # 3. Конкатенация: [визуальная последовательность] + [текстовая последовательность]
        print("\n3. Конкатенация визуальной и текстовой последовательностей...)
        print(f" Форма визуального эмбеддинга: {vision_emb.shape}")
        print(f" Форма текстового эмбеддинга: {text_emb.shape}")
        combined = torch.cat([vision_emb, text_emb], dim=1)
        print(f" Форма после конкатенации: {combined.shape}")

        # 4. LLM генерирует ответ
        print("\n4. LLM генерирует ответ...)

        return "Это милый рыжий кот, он выглядит очень счастливым."


# Демонстрация вопросов и ответов VLM
vlm = SimpleVLM()
answer = vlm.generate(
    image="Фото рыжего кота",
    question="Что на этой картинке? Пожалуйста, опишите её."
)

print(f"\nОтвет: {answer}")


# ============================================
# Пример кода для фактического использования LLaVA
# ============================================
print("\n" + "=" * 60)
print("Пример кода для фактического использования LLaVA:")
print("=" * 60)
print("""
# LLaVA требует много памяти GPU, рекомендуется использовать библиотеку transformers или llava

from transformers import AutoProcessor, AutoModelForVisionAndLanguageGeneration
import torch
from PIL import Image

# 1. Загрузить модель и процессор
model_id = "llava-hf/llava-1.5-7b-hf"
processor = AutoProcessor.from_pretrained(model_id)
model = AutoModelForVisionAndLanguageGeneration.from_pretrained(
    model_id,
    torch_dtype=torch.float16,
    device_map="auto"
)

# 2. Подготовить входные данные
image = Image.open("cat.jpg")
prompt = "USER: <image>\\nЧто изображено на этой картинке? Пожалуйста, опишите это. ASSISTANT:"

inputs = processor(images=image, text=prompt, return_tensors="pt").to("cuda")

# 3. Генерация
with torch.no_grad():
    output = model.generate(**inputs, max_new_tokens=500)
answer = processor.decode(output[0], skip_special_tokens=True)

print(answer)
"""
)

Практика: полный проект по классификации изображений + обнаружению объектов

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

Пример

# ============================================
# Практический проект: полный пайплайн Vision AI
# Включает классификацию изображений, обнаружение объектов и визуализацию результатов
# ============================================

import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import Dataset, DataLoader
import numpy as np
from PIL import Image
import json
from pathlib import Path


class VisionPipeline:
    """
Полный конвейер Vision AI

Возможности:
1. Классификация изображений
2. Обнаружение объектов
3. Сводка результатов и визуализация
    """


    def __init__(self, device: str = "cpu"):
        self.device = device
        self.classifier = None
        self.detector = None
        print(f"ПРИМЕР Vision Pipeline инициализирован (device: {device})")

    def build_classifier(self, num_classes: int = 10):
        """Построить классификатор изображений"""
        print("\nПостроение классификатора изображений...)
        # Использовать ранее определённый SimpleCNN
        self.classifier = SimpleCNN(num_classes=num_classes).to(self.device)
        print("Классификатор изображений успешно построен!")
        return self

    def build_detector(self):
        """Построить детектор объектов"""
        print("\nПостроение детектора объектов...)
        self.detector = SimpleYOLO()
        print("Детектор успешно построен!")
        return self

    def load_pretrained_weights(self, classifier_path: str = None):
        """Загрузить предварительно обученные веса"""
        if classifier_path and self.classifier:
            print(f"\nЗагрузка весов классификатора: {classifier_path}")
            # На практике: self.classifier.load_state_dict(torch.load(classifier_path))
        return self

    def classify_image(self, image: np.ndarray) -> tuple:
        """
Классификация изображений

Возвращает:
            (pred_class_id, pred_class_name, confidence)
        """

        if self.classifier is None:
            raise ValueError("Сначала создайте классификатор: build_classifier()")

        # Предобработка
        if isinstance(image, np.ndarray):
            if image.ndim == 2:  # Оттенки серого
                image = np.stack([image]*3, axis=-1)
            image = torch.from_numpy(image).permute(2, 0, 1).float() / 255.0
            image = F.interpolate(image.unsqueeze(0), size=(32, 32), mode='bilinear')
            image = image.to(self.device)

        # Инференс
        self.classifier.eval()
        with torch.no_grad():
            logits = self.classifier(image)
            probs = F.softmax(logits, dim=-1)
            confidence, pred_idx = probs.max(dim=-1)

        # Возврат результата
        class_names = [
            'самолет', 'автомобиль', 'птица', 'кошка', 'олень',
            'собака', 'лягушка', 'лошадь', 'корабль', 'грузовик'
        ]
        pred_class = class_names[pred_idx.item()]

        return pred_idx.item(), pred_class, confidence.item()

    def detect_objects(self, image: np.ndarray) -> list:
        """Обнаружение объектов"""
        if self.detector is None:
            raise ValueError("Сначала создайте детектор: build_detector()")

        # Использовать имитированное обнаружение
        return self.detector.predict_dummy(image)

    def process_image(self, image: np.ndarray) -> dict:
        """
Обработать всё изображение

Возвращает:
Словарь, содержащий все результаты
        """

        print("\n" + "=" * 60)
        print("Начало обработки изображения")
        print("=" * 60)

        results = {}

        # 1. Классификация изображения
        if self.classifier is not None:
            print("\n[1/3] Запуск классификации изображения...")
            class_id, class_name, conf = self.classify_image(image)
            results['classification'] = {
                'class_id': class_id,
                'class_name': class_name,
                'confidence': conf
            }
            print(f" → Результат классификации: {class_name} (Уверенность: {conf:.2%})")

        # 2. Обнаружение объектов
        if self.detector is not None:
            print("\n[2/3] Запуск обнаружения объектов...")
            detections = self.detect_objects(image)
            results['detections'] = detections
            print(f" → Обнаружено {len(detections)} объектов:")
            for det in detections:
                print(f" - {det['class_name']} ({det['score']:.2f})")

        # 3. Визуализация
        print("\n[3/3] Создание визуализации...")
        if self.detector is not None:
            vis_image = self.detector.visualize(image, detections)
            results['visualization'] = vis_image
            print(" → Визуализация завершена")

        print("\n" + "=" * 60)
        print("Обработка изображения завершена!")
        print("=" * 60)

        return results

    def save_results(self, results: dict, output_dir: str = "output"):
        """Сохранить результаты в файл"""
        output_path = Path(output_dir)
        output_path.mkdir(exist_ok=True)

        # Сохранить результаты JSON
        json_result = {
            'classification': results.get('classification'),
            'detections': [
                {k: v for k, v in det.items() if k != 'bbox'}
                for det in results.get('detections', [])
            ]
        }
        with open(output_path / "results.json", "w") as f:
            json.dump(json_result, f, indent=2, ensure_ascii=False)

        # Сохранить изображение визуализации
        if 'visualization' in results:
            vis = Image.fromarray(results['visualization'])
            vis.save(output_path / "visualization.jpg")

        print(f"\nРезультаты сохранены в: {output_path}/")


# Полный пример обучения
class SimpleDataset(Dataset):
    """Простой имитированный набор данных"""

    def __init__(self, num_samples: int = 100):
        self.num_samples = num_samples
        # Сгенерировать фиктивные данные
        self.images = torch.randn(num_samples, 3, 32, 32)
        self.labels = torch.randint(0, 10, (num_samples,))

    def __len__(self):
        return self.num_samples

    def __getitem__(self, idx):
        return self.images[idx], self.labels[idx]


def train_classifier(pipeline: VisionPipeline, num_epochs: int = 5):
    """Полный рабочий процесс для обучения классификатора"""
    print("\n" + "=" * 60)
    print("Начинаем обучение классификатора")
    print("=" * 60)

    # 1. Подготовка данных
    print("\nПодготовка набора данных...")
    train_dataset = SimpleDataset(1000)
    val_dataset = SimpleDataset(200)

    train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
    val_loader = DataLoader(val_dataset, batch_size=32)

    print(f"Обучающая выборка: {len(train_dataset)} примеров")
    print(f"Валидационная выборка: {len(val_dataset)} примеров")

    # 2. Оптимизатор и функция потерь
    optimizer = torch.optim.Adam(pipeline.classifier.parameters(), lr=1e-3)
    criterion = nn.CrossEntropyLoss()

    # 3. Цикл обучения
    print("\nНачало обучения...")
    for epoch in range(num_epochs):
        pipeline.classifier.train()
        total_loss = 0.0
        correct = 0
        total = 0

        for images, labels in train_loader:
            images, labels = images.to(pipeline.device), labels.to(pipeline.device)

            optimizer.zero_grad()
            outputs = pipeline.classifier(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

            total_loss += loss.item()
            _, predicted = outputs.max(1)
            total += labels.size(0)
            correct += predicted.eq(labels).sum().item()

        train_acc = correct / total
        avg_loss = total_loss / len(train_loader)

        # Валидация
        pipeline.classifier.eval()
        correct = 0
        total = 0
        with torch.no_grad():
            for images, labels in val_loader:
                images, labels = images.to(pipeline.device), labels.to(pipeline.device)
                outputs = pipeline.classifier(images)
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()

        val_acc = правильных / всего

        print(f"Эпоха {epoch+1}/{num_epochs} - "
              f"Потери: {avg_loss:.4f}, "
              f"Точность обучения: {train_acc:.2%}, "
              fТочность валидации: {val_acc:.2%})

    print("\nОбучение завершено!)


# ============================================
Запустите полный практический проект.
# ============================================

print("=" * 60)
print(ПРИМЕР Визуальный ИИ Полный практический проект)
print("=" * 60)

# 1. Создать конвейер
pipeline = VisionPipeline(device="cuda" if torch.cuda.is_available() else "cpu")

# 2. Построить модель
pipeline.build_classifier(num_classes=10)
pipeline.build_detector()

3. Обучение классификатора
train_classifier(pipeline, num_epochs=3)

# 4. Обработка изображений
test_image = create_test_image()
results = pipeline.process_image(test_image)

5. Сохраните результат
pipeline.save_results(results, output_dir="example_output")

print("\n" + "=" * 60)
print(Выполнение проекта завершено!)
print("=" * 60)
print("\nРекомендации по дальнейшему обучению:)
print(1. Попробуйте обучение на реальном наборе данных (например, CIFAR-10).)
print(2. Тонкая настройка с использованием предобученной модели)
print(3. Попробуйте более сложные архитектуры моделей.)
print(4. Внедрите в практические приложения.)
Другие расширения