Блок схема программы сегментации изображения. Обзор алгоритмов сегментации. Маркер представляет собой связную компоненту, принадлежащую изображению. Также перед проведением сегментации по водоразделам проведена необходимая предварительная обработка изобра

Линейное увеличение сферического зеркала

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

Математическая разминка (м/р).

Проверка домашнего задания.

Изучение нового материала.

Разминка.

Решение задач.

Домашнее задание.

7. подведение итогов.

Ход урока:

1. Математическая разминка

Палка высотой 1,2м, освещаемая солнцем, отбрасывает тень длиной 1,6м. Определить длину тени дерева, если известно, что высота его 15м.

2. Проверка Д/З

Построить зеркала по предмету и изображению:

3. Новая тема: Линейное увеличение сферических зеркал/

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

А 1 Р = а – расстояние от полюса зеркала до изображения.

АР = b - расстояние от полюса зеркала до предмета.

А 1 В 1 = Н – линейный размер изображения.

АВ = h – линейный размер предмета.

Из подобия треугольников АОВ и А 1 ОВ 1 видим, что b /а = Н /h . Это отношение показывает, во сколько раз отличаются размеры изображения и предмета. С точки зрения геометрии это есть коэффициент подобия, но этот коэффициент подобия имеет и физический смысл и называется линейным увеличением.

У = Н/h = b/ а

Определение:

Линейным увеличением называют отношение линейного размера изображения к линейному размеру предмета.

У>1 - изображение увеличенное;

У<1 - изображение уменьшенное;

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

4. Разминка

Посмотрели на макушки деревьев.

Прочитали определение линейного увеличения.

Снова посмотрели на макушки деревьев.

Посмотрели и запомнили формулу линейного увеличения.

Прогнулись в пояснице.

Соединили лопатки, потянулись.

Встали все, задвинули стулья.

5.Решение задач.

Класс делится на 4 группы, работа продолжается стоя.

Каждая группа получает задание на листке и расчетную задачу на увеличение.

Ответы готовятся в течении 5 минут.

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

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

Что за зеркало и для чего носят на лбу врачи-отоларингологи.? Для чего в середине этого зеркала располагается отверстие?

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

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

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

Группы сообщают свои ответы, учитель проверяет их расчетные задачи на увеличение.

6.Домашнее задание : учебник А.А.Пинского и др. П. 43, № 43.7

7. Подведение итогов.

Сегментация изображений с U-Net на практике

Введение

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

1. как источник для вдохновения.
2. Pytorch как инструмент для реализации нашей задумки.
3. Kaggle соревнования как место где мы можем опробовать наши гипотезы на реальных данных.

Мы не будем следовать на 100% за статьей, но мы постараемся реализовать ее суть, адаптировать под наши нужды.

Презентация проблемы

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

Для понимания того что мы хотим, gif изображение ниже:

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

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

Структура кода

Код был максимально упрощен для понимания как это работает. Основной код находится в этом файле main.py , разберем его построчно.

Код

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

Давайте начнем с начала :

def main (): # Hyperparameters input_img_resize = (572 , 572 ) # The resize size of the input images of the neural net output_img_resize = (388 , 388 ) # The resize size of the output images of the neural net batch_size = 3 epochs = 50 threshold = 0. 5 validation_size = 0. 2 sample_size = None # -- Optional parameters threads = cpu_count() use_cuda = torch.cuda.is_available() script_dir = os.path.dirname(os.path.abspath(__file__ )) # Training callbacks tb_viz_cb = TensorboardVisualizerCallback(os.path.join(script_dir,"../logs/tb_viz" )) tb_logs_cb = TensorboardLoggerCallback(os.path.join(script_dir,"../logs/tb_logs" )) model_saver_cb = ModelSaverCallback(os.path.join(script_dir,"../output/models/model_" + helpers.get_model_timestamp()), verbose= True )

В первом разделе вы определяете свои гиперпараметры, их можете настроить по своему усмотрению, например в зависимости от вашей памяти GPU. Optimal parametes определяют некоторые полезные параметры и callbacks . TensorboardVisualizerCallback - это класс, который будет сохранять предсказания в tensorboard в каждую эпоху тренировочного процесса, TensorboardLoggerCallback сохранит значения функций потерь и попиксельную «точность» в tensorboard . И наконец ModelSaverCallback сохранит вашу модель после завершения обучения.

# Download the datasets ds_fetcher = DatasetFetcher () ds_fetcher. download_dataset()

Этот раздел автоматически загружает и извлекает набор данных из Kaggle. Обратите внимание, что для успешной работы этого участка кода вам необходимо иметь учетную запись Kaggle с логином и паролем, которые должны быть помещены в переменные окружения KAGGLE_USER и KAGGLE_PASSWD перед запуском скрипта. Также требуется принять правила конкурса, перед загрузкой данных. Это можно сделать на вкладке загрузки данных конкурса

# Get the path to the files for the neural net X_train, y_train, X_valid, y_valid = ds_fetcher.get_train_files(sample_size= sample_size, validation_size= validation_size) full_x_test = ds_fetcher.get_test_files(sample_size) # Testing callbacks pred_saver_cb = PredictionsSaverCallback(os.path.join (script_dir,"../output/submit.csv.gz" ), origin_img_size, threshold)

Эта строка определяет callback функцию для теста (или предсказания). Она будет сохранять предсказания в файле gzip каждый раз, когда будет произведена новая партия предсказания. Таким образом, предсказания не будут сохранятся в памяти, так как они очень большие по размеру.

После окончания процесса предсказания вы можете отправить полученный файл submit.csv.gz из выходной папки в Kaggle.

# -- Define our neural net architecture # The original paper has 1 input channel, in our case we have 3 (RGB ) net = unet_origin. UNetOriginal ((3 , *img_resize)) classifier = nn. classifier. CarvanaClassifier (net, epochs) optimizer = optim. SGD (net. parameters() , lr= 0.01 , momentum= 0.99 ) train_ds = TrainImageDataset (X_train , y_train, input_img_resize, output_img_resize, X_transform = aug. augment_img) train_loader = DataLoader (train_ds, batch_size, sampler= RandomSampler (train_ds), num_workers= threads, pin_memory= use_cuda) valid_ds = TrainImageDataset (X_valid , y_valid, input_img_resize, output_img_resize, threshold= threshold) valid_loader = DataLoader (valid_ds, batch_size, sampler= SequentialSampler (valid_ds), num_workers= threads, pin_memory= use_cuda)

print ("Training on {} samples and validating on {} samples " . format(len(train_loader. dataset), len(valid_loader. dataset))) # Train the classifier classifier. train(train_loader, valid_loader, epochs, callbacks= )

test_ds = TestImageDataset (full_x_test, img_resize) test_loader = DataLoader (test_ds, batch_size, sampler= SequentialSampler (test_ds), num_workers= threads, pin_memory= use_cuda) # Predict & save classifier. predict(test_loader, callbacks= ) pred_saver_cb. close_saver()

Наконец, мы делаем то же самое, что и выше, но для прогона предсказания. Мы вызываем наш pred_saver_cb.close_saver() , чтобы очистить и закрыть файл, который содержит предсказания.

Реализация архитектуры нейронной сети

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

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

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

В то время, когда была написана работа, были пропущены 2 вещи, которые сейчас необходимы для ускорения сходимости нейронной сети:

1. BatchNorm.
2. Мощные GPU.

Первое был изобретено всего за 3 месяца до Unet , и вероятно слишком рано, чтобы авторы Unet добавили его в свою статью.

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

Что касается графических процессоров, в статье говорится:

To minimize the overhead and make maximum use of the GPU memory, we favor large input tiles over a large batch size and hence reduce the batch to a single image

Они использовали GPU с 6 ГБ RAM, но в настоящее время у GPU больше памяти, для размещения изображений в одном batch’e. Текущий batch равный трем, работает для графического процессора в GPU с 8 гб RAM. Если у вас нет такой видеокарты, попробуйте уменьшить batch до 2 или 1.

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

Теперь давайте начнем с самого начала, проектируя архитектуру нейронной сети:

Вот как выглядит Unet. Вы можете найти эквивалентную реализацию Pytorch в модуле nn.unet_origin.py.

Все классы в этом файле имеют как минимум 2 метода:

• __init__() где мы будем инициализировать наши уровни нейронной сети;
• forward() который является методом, называемым, когда нейронная сеть получает вход.

Давайте рассмотрим детали реализации:

• ConvBnRelu - это блок, содержащий операции Conv2D, BatchNorm и Relu. Вместо того, чтобы набирать их 3 для каждого стека кодировщика (группа операций вниз) и стеков декодера (группа операций вверх), мы группируем их в этот объект и повторно используем его по мере необходимости.
• StackEncoder инкапсулирует весь «стек» операций вниз, включая операции ConvBnRelu и MaxPool , как показано ниже:

Мы отслеживаем вывод последней операции ConvBnRelu в x_trace и возвращаем ее, потому что мы будем конкатенировать этот вывод с помощью стеков декодера.

• StackDecoder - это то же самое, что и StackEncoder, но для операций декодирования, окруженных ниже красным:

Обратите внимание, что он учитывает операцию обрезки / конкатенации (окруженную оранжевым), передавая в down_tensor, который является не чем иным, как тензором x_trace, возвращаемым нашим StackEncoder .

• UNetOriginal - это место, где происходит волшебство. Это наша нейронная сеть, которая будет собирать все маленькие кирпичики, представленные выше. Методы init и forward действительно сложны, они добавляют кучу StackEncoder , центральной части и под конец несколько StackDecoder . Затем мы получаем вывод StackDecoder , добавляем к нему свертку 1x1 в соответствии со статьей, но вместо того, чтобы определять два фильтра в качестве вывода, мы определяем только 1, который фактически будет нашим прогнозом маски в оттенках серого. Далее мы «сжимаем» наш вывод, чтобы удалить размер канала (всего 1, поэтому нам не нужно его хранить).

Если вы хотите понять больше деталей каждого блока, поместите контрольную точку отладки в метод forward каждого класса, чтобы подробно просмотреть объекты. Вы также можете распечатать форму ваших тензоров вывода между слоями, выполнив печать (x.size() ).

Тренировка нейронной сети

1. Функция потерь

Теперь к реальному миру. Согласно статье:

The energy function is computed by a pixel-wise soft-max over the final feature map combined with the cross-entropy loss function.

Дело в том, что в нашем случае мы хотим использовать dice coefficient как функцию потерь вместо того, что они называют «энергетической функцией», так как это показатель, используемый в соревновании Kaggle , который определяется:

X является нашим предсказанием и Y - правильно размеченной маской на текущем объекте. |X| означает мощность множества X (количество элементов в этом множестве) и ∩ для пересечения между X и Y .

Код для dice coefficient можно найти в nn.losses.SoftDiceLoss .

class SoftDiceLoss (nn.Module): def __init__(self, weight= None, size_average= True): super (SoftDiceLoss, self).__init__() def forward(self, logits, targets): smooth = 1 num = targets.size (0 ) probs = F.sigmoid(logits) m1 = probs.view(num, - 1 ) m2 = targets.view(num, - 1 ) intersection = (m1 * m2) score = 2 . * (intersection.sum(1 ) + smooth) / (m1.sum(1 ) + m2.sum(1 ) + smooth) score = 1 - score.sum() / num return score

Причина, по которой пересечение реализуется как умножение, и мощность в виде sum() по axis 1 (сумма из трех каналов) заключается в том, что предсказания и цель являются one-hot encoded векторами.

Например, предположим, что предсказание на пикселе (0, 0) равно 0,567, а цель равна 1, получаем 0,567 * 1 = 0,567. Если цель равна 0, мы получаем 0 в этой позиции пикселя.

Мы также использовали плавный коэффициент 1 для обратного распространения. Если предсказание является жестким порогом, равным 0 и 1, трудно обратно распространять dice loss .

Затем мы сравним dice loss с кросс-энтропией, чтобы получить нашу функцию полной потери, которую вы можете найти в методе _criterion из nn.Classifier.CarvanaClassifier . Согласно оригинальной статье они также используют weight map в функции потери кросс-энтропии, чтобы придать некоторым пикселям большее ошибки во время тренировки. В нашем случае нам не нужна такая вещь, поэтому мы просто используем кросс-энтропию без какого-либо weight map.

2. Оптимизатор

Поскольку мы имеем дело не с биомедицинскими изображениями, мы будем использовать наши собственные augmentations . Код можно найти в img.augmentation.augment_img . Там мы выполняем случайное смещение, поворот, переворот и масштабирование.

Тренировка нейронной сети

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

Для этого вам нужно запустить Tensorboard в папке logs с помощью команды:

Tensorboard --logdir=./logs

Пример того, что вы сможете увидеть в Tensorboard после эпохи 1: