Часть 3: Использование LIME в приложении React
Автор Тигран Аветисян
Это ЧАСТЬ 3 нашей серии из 3 ЧАСТЕЙ «Сравнение объяснимых платформ ИИ».
См. ЧАСТЬ 1 здесь и ЧАСТЬ 2 здесь.
В ЧАСТИ 2 мы исследовали возможности LIME для классификации изображений. Мы обнаружили, что хотя LIME сложнее в использовании, чем SHAP, он лучше поддерживает TensorFlow 2 и обеспечивает большую гибкость.
В ЧАСТИ 3 мы собираемся использовать LIME в приложении React.js, подобно нашим приложениям Hugging Face, TPOT и MLflow. Мы покажем вам, как создать Python API для объяснения моделей классификации изображений и как этот API можно интегрировать в приложение React.
Давайте начнем наше руководство с краткого обзора нашего приложения!
Обзор нашего приложения
Наше приложение React.js направлено на то, чтобы абстрагироваться от шагов кодирования, которые необходимо выполнить для создания объяснений с помощью платформы LIME. Приложение позволяет:
· Объясните выходные данные моделей классификации изображений TensorFlow.
· Загрузите свои собственные изображения, чтобы объяснить их.
· Настройте параметры трех алгоритмов сегментации, которые поддерживает LIME, чтобы получить более четкие и убедительные объяснения.
· Объясните изображения в соответствии с прогнозами вашей модели или в отношении конкретных меток, которые вы указали.
· Просмотр положительных/отрицательных областей на изображениях и настройка большинства параметров объяснения LIME.
Приложение имеет некоторые ограничения и не реализует все возможности LIME. Мы рассмотрим ограничения нашего приложения более подробно ниже.
Предпосылки для подачи заявки
Чтобы собрать и запустить наше приложение, вам понадобятся три вещи:
· Node.js, который можно скачать здесь.
· Ряд пакетов Python для API.
Если вы работаете в Windows, мы также рекомендуем Git. Git позволит вам запускать сценарии оболочки и обрабатывать репозитории GitHub.
Пакеты Python, которые вам понадобятся, следующие:
· Быстрый API.
· Увикорн.
· Python-многочастный.
· Пидантик.
· Айофайлы.
· Матплотлиб.
· ТензорФлоу.
· НумПи.
· ЛАЙМ.
Если вы используете диспетчер пакетов pip, выполните команду pip install [package-name]. Если вы используете conda, установите пакеты с помощью conda install -c conda-forge [package-name] .
Однако для LIME вам может потребоваться клонировать репозиторий пакета GitHub на локальный компьютер и установить его оттуда. Это связано с тем, что когда мы устанавливали LIME с помощью pip install, некоторые ключевые функции, необходимые для API, отсутствовали в исходном коде библиотеки на нашем компьютере. При этом исходный код на GitHub явно содержал нужный нам функционал, поэтому мы знали, что что-то не так.
Чтобы установить LIME из локального каталога, сделайте следующее:
1. Клонируйте репозиторий LIME на свой локальный компьютер, запустив git clone https://github.com/marcotcr/lime.gitв каталоге, в котором вы хотите сохранить пакет. Если вы работаете в Windows, вы можете использовать Git или GitHub Desktop, чтобы клонировать репозиторий.
2. Перейдите в каталог над клонированным репозиторием.
3. Откройте терминал и выполните следующую команду — pip install -e lime, где lime — локальный путь к файлам репозитория.
Обратите внимание, что в отличие от наших предыдущих руководств по приложениям, мы используем FastAPI вместо Flask для создания API Python. FastAPI делает синтаксический анализ аргументов намного аккуратнее и проще, чем Flask, что было одной из причин, по которой мы решили использовать другой фреймворк.
Создание API
После того, как вы обработаете зависимости, вы можете приступить к созданию API!
Импорт зависимостей
Как обычно, мы начинаем с импорта зависимостей:
Помимо инструментов, которые нам нужны для объяснения изображений, мы также импортируем несколько классов FastAPI, которые помогут нам создать API и модели данных для HTTP-запросов.
Создание объектов запроса
Нам нужно будет отправить следующие типы данных в наш API:
· Органы запроса.
· Форма данных.
В этом разделе мы кратко рассмотрим тела запросов и покажем, как мы использовали их в нашем API. Что касается данных формы, мы рассмотрим их в действии, когда начнем определять конечные точки нашего API.
Нам понадобится два тела запроса — одно будет обрабатывать аргументы для генерации объяснения, а другое — аргументы выбранного нами алгоритма сегментации.
Тела запросов в FastAPI полагаются на Pydantic — библиотеку Python, которая позволяет выполнять проверку данных и управление настройками. Чтобы создать текст запроса, вы наследуете класс от класса Pydantic BaseModel. Этот класс, называемый моделью данных, будет перечислять аргументы, которые требуются нашему API.
Когда FastAPI получит запрос, он будет:
1. Прочитайте тело запроса в формате JSON.
2. Преобразуйте аргументы в соответствующие типы данных.
3. Проверьте данные, чтобы убедиться, что они соответствуют подписи, определенной в модели данных.
4. Вернуть данные, если они прошли проверку.
FastAPI также генерирует определения JSON Schema для тел запросов, что помогает создавать автоматическую документацию (подробнее об этом позже).
Для наших аргументов объяснения объявление модели данных выглядит следующим образом:
Смысл этих аргументов следующий:
· image_indicesопределяет, для каких изображений, которые вы загружаете, приложение будет генерировать пояснения. Если вы наберете 0, 1, 3, вы получите пояснения к изображениям под индексами 0, 1 и 3.
· top_labels определяет количество прогнозов для загруженных изображений, которые LIME будет хранить. Если вы наберете 3, LIME сохранит 3 лучших прогноза с наивысшей вероятностью. top_labels должно быть меньше или равно общему количеству классов, для прогнозирования которых была обучена ваша модель. top_labelsигнорируется, если labels_to_explain НЕ None.
· top_predictions определяет количество прогнозов из сохраненных top_labels, которые вы хотите объяснить. Если вы наберете 3, LIME создаст объяснения для трех лучших прогнозов. top_predictions должно быть меньше или равно top_labels. top_predictionsигнорируется, если labels_to_explainНЕ равно None.
· labels_to_explain позволяет выбрать конкретные метки для создания пояснений. Если вы установите для этого параметра значение None, LIME будет генерировать пояснения относительно сохраненного top_predictions. Если НЕ None, LIME создаст объяснения относительно предоставленных значений. Например, если вы хотите сгенерировать объяснения для классов 0, 3 и 8, вам нужно будет передать 0, 3, 8 в labels_to_explain. Обратите внимание: если labels_to_explain НЕ None, под image_indices должно быть только ОДНО значение.
· num_samples определяет размер окрестности, которую LIME будет генерировать для объяснения изображений. Более высокие значения могут улучшить ясность объяснения, но увеличат время, необходимое для создания объяснений.
· positive_only, negative_only и hide_restопределяют, какие области будут отображаться и выделяться на изображениях. Когда флажок hide_restне установлен и positive_onlyили negative_only отмечен, LIME будет выделять положительные или отрицательные области соответственно. Если установлен флажок hide_rest и positive_onlyили negative_only установлен, LIME будет показывать только положительные или отрицательные области соответственно и скрывать остальные.
Что касается аргументов сегментатора, то они выглядят так:
Мы не указываем конкретные аргументы ключевого слова для Segmenter, поскольку LIME поддерживает несколько алгоритмов сегментации. Явный ввод всех аргументов был бы беспорядочным — вместо этого мы можем принять аргументы как словарь, а затем передать этот словарь в качестве аргументов ключевого слова в SegmentationAlgorithm.
Настройка API
Далее давайте настроим наш API. Вот как мы можем это сделать:
Мы инициализируем API FastAPI в строке 2. Затем мы настраиваем CORS (совместное использование ресурсов между источниками), чтобы мы могли подключать серверные и внешние интерфейсы, расположенные в разных источниках.
В строках 5 и 6 мы перечисляем источники, которые могут выполнять запросы между источниками. В нашем случае мы разрешаем http://localhost:3000(где будет работать приложение React) и http://localhost :5000(где будет работать FastAPI API). Если компоненты вашего приложения имеют другое происхождение, вам нужно указать их здесь.
В FastAPI CORS обрабатывается классом CORSMiddleware. В строке 9 мы добавляем нашу конфигурацию CORS в приложение, используя CORSMiddleware. Аргументы allow_methods=[“*”]и allow_headers=[“*”]указывают, что разрешены все методы и заголовки HTTP.
Настройка конечных точек
Далее нам нужно настроить конечные точки для нашего приложения. Для целей этого поста мы определили три конечных точки:
· /upload-model/ — конечная точка для загрузки весов модели.
· /upload-images/ — конечная точка для загрузки изображений, которые вы хотите пояснить.
· /explain/ — конечная точка формирования объяснений.
Давайте рассмотрим эти конечные точки одну за другой!
/загрузить-модель/
Чтобы объяснить выходные данные модели, нам сначала нужно иметь возможность передать эту модель в API. За это отвечает конечная точка /upload-model/.
FastAPI представляет конечные точки как функции Python, которые принимают пользовательские аргументы. Вы украшаете эти функции встроенными декораторами FastAPI, такими как @app.getили @app.post, чтобы указать, какой метод HTTP будет обрабатывать звонки на эту конечную точку. Вы передаете строку декоратору, чтобы указать URL-адрес конечной точки.
Учитывая все это, объявление нашей конечной точки выглядит так:
Обратите внимание, что имя функции в декораторе может быть любым. Параметры, перечисленные в определении функции (weightsи arch), являются аргументами, которые вы должны предоставлять при отправке HTTP-запросов.
weightsи archв нашей функции имеют тип UploadFile. UploadFileуказывает, что эта конечная точка ожидает получить файл как часть данных формы. FastAPI кодирует UploadFileкак multipart/form-data, а тело запроса кодируется как application/json. Вы можете комбинировать несколько форм и UploadFileпараметров, но вы не можете комбинировать данные формы с телом запроса из-за ограничений протокола HTTP.
В любом случае, в нашей конечной точке мы:
1. Используйте aiofiles.open, чтобы открыть файл в режиме ‘wb’ (writeи binary) (строка 5) для обработки полученных модельных весов.
2. Асинхронно прочитать содержимое байта weights (строка 7) и записать его в хранилище сервера (строка 10), чтобы мы могли загрузить веса позже.
3. Асинхронно прочитать файл архитектуры модели (строка 13) как байты.
4. Загрузите архитектуру модели из байтов архитектуры и сохраните модель в приложении (строка 16).
5. Скомпилируйте модель (строка 19).
6. Загрузите сохраненные веса модели (строка 22).
/загрузить изображения/
Объявление /upload-images/выглядит следующим образом:
В этой конечной точке мы определяем обязательный параметр imagesс типом данных List[UploadFile]. Нам нужен список UploadFileобъектов, потому что мы хотим принять более одного изображения.
В этой конечной точке мы делаем следующее:
1. Создайте в приложении пустой список, в котором будут храниться переданные изображения (строка 5). Если изображения из предыдущих вызовов этой конечной точки существуют, они удаляются.
2. Перебрать изображения (строки с 8 по 19).
3. Асинхронно прочитать содержимое байтов текущего изображения (строка 10).
4. Преобразуйте изображение в массив NumPy (строка 13) и нормализуйте его (строка 16).
5. Сохраните изображение в приложении (строка 19).
API повторяет эти шаги для каждого предоставленного изображения.
/объяснять/
Код для этой конечной точки выглядит так:
В определении функции мы перечисляем параметры explanation_params: Explanationи segmenter_params: Segmenter. Они соответствуют моделям данных, которые мы объявили для объяснения и аргументов сегментатора ранее.
Внутри функции делаем следующее:
1. Придумайте пояснения к предоставленным изображениям (строки 7–8).
2. Проверьте, предоставил ли пользователь определенные метки для объяснения изображений (строки с 11 по 16). Если да, то будут сгенерированы объяснения для предоставленных меток (строка 13), если нет, будут сгенерированы объяснения в отношении прогнозов модели (строка 15).
Эти шаги основаны на нескольких вспомогательных функциях за пределами функции конечной точки — подробнее ниже.
Вспомогательные функции для пояснений
У нас есть четыре вспомогательные функции, которые помогут нам генерировать объяснения:
· create_segmenter– обрабатывает создание алгоритма сегментации.
· generate_explanations– создает пояснения к предоставленным изображениям.
· explain_images_with_respect_to_labels — если указаны специальные метки, поясняет изображения относительно них.
· explain_images_with_respect_to_predictions — если специальные метки не указаны, поясняет изображения относительно предсказаний модели, сохраненных LIME.
Давайте теперь рассмотрим эти функции одну за другой.
create_segmenter
create_segmenterэто очень простая функция: она просто берет segmenter_paramsи передает их в SegmentationAlgorithmLIME. >в качестве аргументов ключевого слова:
Чистый, простой и подходящий для работы с несколькими поддерживаемыми алгоритмами сегментации!
generate_explanations
Возможно, самая важная функция в нашем API, generate_explanationsвыдает пояснения к нашим изображениям. Функция выглядит следующим образом:
В этой функции мы:
1. Создайте экземпляр объекта LimeImageExplainer(строка 6).
2. Проверьте, какой алгоритм сегментации был запрошен, и определите его аргументы типа float и integer, которые должны быть преобразованы из строк в соответствующий тип данных (строки 11–19). Мы делаем это, потому что наш API преобразует все значения в segmenter_params.argsсловаре в строки.
3. Преобразование строковых чисел с плавающей запятой в числа с плавающей запятой (строки 22–23) и строковых целых чисел в целые числа (строки 26–27).
4. Создайте сегментатор с помощью segmenter_params(строка 30).
5. Создайте пустой список для хранения пояснений в нашем приложении (33). Любые объяснения, сохраненные в предыдущих запусках, удаляются в этой строке.
6. Переберите изображения, которые мы передали /upload-images/, создайте для них пояснения и сохраните пояснения в app.explanations (строки 36–44). ).
объясните_изображения_с_уважением_к_ярлыкам
explain_images_with_respect_to_labelsвыглядит так:
В этой функции мы:
1. Получить сохраненные пояснения (строка 4).
2. Разбить explanation_params.labels_to_explain на список строковых чисел (строка 7) и преобразовать их в целые числа (строки 10–11).
3. Динамически определить количество строк и столбцов для графика объяснения (строки с 15 по 26). Если количество меток для объяснения меньше 5, количество строк устанавливается равным 1, а количество столбцов устанавливается равным количеству меток. Если количество меток больше 5, количество строк устанавливается равным int(np.ceil(len(labels_to_explain) / 5)), а количество столбцов — равным 5. В последнем случае у нас будет больше осей чем метки для объяснения, а это означает, что эти оси не будут содержать никаких объяснений и их нужно будет отключить.
4. Создайте фигуру с подграфиками (строка 29) и измените ее размер в соответствии с количеством строк и столбцов (строка 30).
5. Получите объяснение, соответствующее explanation_params.image_indices(строка 33).
6. Объявите счетную переменную counter (строка 36).
7. Перебираем наши строки и столбцы, нанося пояснения до индекса counter(строки с 39 по 61). Если нужно объяснить больше осей, чем меток, counterпозволит нам прекратить построение графика, как только мы объясним все предоставленные метки. counter увеличивается после построения графика каждого пояснения.
8. Выключите оси после counter(строки 64–65).
9. Подтяните элементы на рисунке (строка 68) и сохраните схему с пояснениями (строка 71).
объясните_изображения_с_уважением_к_предсказаниям
Наконец, explain_images_with_respect_to_predictions выглядит так:
В этой функции мы:
1. Получить сохраненные пояснения (строка 4).
2. Разбить explanation_params.image_indices на список строковых чисел (строка 7) и преобразовать их в целые числа (строки 10–11).
3. Динамически определить количество строк и столбцов на графике (строки с 17 по 18). Мы устанавливаем количество строк равным количеству индексов изображения. Количество столбцов — explanation_params.top_predictions + 1, где explanation_params.top_predictions — количество прогнозов, которые мы хотим объяснить, а 1 — дополнительный столбец для исходного изображения.
4. Создайте фигуру с подграфиками (строка 21) и измените ее размер в соответствии с количеством строк и столбцов (строка 22).
5. Итерация по индексам изображения (строки 25–54), получение объяснения текущего индекса (строка 27), отображение исходного изображения (строки 30–34) и построение объяснений для лучших прогнозов (строки 39–54). .
6. Подтяните элементы на рисунке (строка 57) и сохраните сюжет с пояснениями (строка 60).
Запуск API
Запустить FastAPI API можно двумя способами:
· С терминала.
· Программно, из скрипта Python.
В любом из них вам понадобится серверная библиотека ASGI, такая как Uvicorn или Hypercorn. Мы будем использовать Uvicorn.
Чтобы запустить наш API из терминала, вам нужно сделать следующее:
1. Поместите весь код Python в файл сценария .py. Для целей данного руководства назовите сценарий lime-api.py.
2. Откройте терминал в локации lime-api.py.
3. Запустите команду uvicorn lime-api:app. lime-apiв команде относится к имени нашего скрипта (без расширения файла), а appявляется идентификатор (имя) объекта FastAPI, который мы создаем в нашем скрипте.
Вы можете передать дополнительные аргументы команде uvicorn, например:
uvicorn lime-api:app — port 5000 — reload
Аргумент --port 5000 указывает порт, к которому мы хотим привязать наше приложение. --reloadобеспечивает автоматическую перезагрузку API каждый раз, когда вы вносите изменения в его код.
В качестве альтернативы, чтобы запустить сервер ASGI программно, добавьте следующее в конец сценария API:
https://gist.github.com/tavetisyan95/7383806720ae52d7e92e4fef5839fc97
Обратите внимание, что вы не сможете программно запустить Uvicorn из блокнота Jupyter. Если вы не можете заставить FastAPI работать из блокнота Jupyter, просто скопируйте свой код в скрипт .py и запустите его.
Просмотр документации по автоматическому API
Одна действительно крутая функция FastAPI — автоматическая документация. По сути, FastAPI может захватывать ваши конечные точки и их аргументы и автоматически генерировать для них простую страницу документации.
После запуска API вы можете получить доступ к странице его документации, посетив http://localhost:5000/docs. Для нашего API вы должны увидеть что-то вроде этого:
Вы можете нажать на отдельные конечные точки под default и проверить их параметры и определенные ответы:
Вы даже можете протестировать каждую из конечных точек, нажав Try it out вверху и предоставив необходимые данные. Эта функция действительно помогла нам устранить неполадки в нашем API и выяснить, как заставить его работать с различными типами входных данных.
Использование нашего API в приложении React
Мы использовали описанный выше API для создания приложения React. Приложение позволяет объяснять модели классификации изображений без написания кода.
Обратите внимание: чтобы иметь возможность использовать наш API в приложении React, мы внесли небольшие изменения в некоторые URL-адреса, чтобы мы могли докеризировать приложение.
Ниже вы найдете инструкции по запуску и использованию приложения. Давайте идти!
Клонирование репозитория
Для начала выполните эту команду в терминале (или в Bash, если вы работаете в Windows), чтобы клонировать репозиторий приложения:
git clone https://github.com/tavetisyan95/lime_web_app.git
Репозиторий содержит наш Python API, внешний интерфейс React, а также ряд файлов и изображений модели TF, которые помогут вам протестировать приложение.
Редактирование портов и конечных точек (при необходимости)
config.jsв каталогеapp/lime_web_app/src/определяет порты и конечные точки, которые будет использовать наше приложение React. для отправки запросов:
Редактирование этого файла не изменит фактические порты и конечные точки, используемые нашим API, — это повлияет только на URL-адреса, на которые приложение будет отправлять HTTP-запросы. Если вы решите изменить порты или конечные точки в коде API, не забудьте также внести изменения в config.js. Если возможно, не меняйте порт http-server.
Запуск приложения
После клонирования репозитория запустите приложение Docker на своем компьютере. Затем перейдите в клонированный репозиторий и выполните в терминале следующее:
docker-compose -f docker-compose.yaml up -d –build
Приложению потребуется некоторое время, чтобы установить зависимости и полностью запуститься.
Вы узнаете, что приложение запущено, когда терминал сообщит о запуске контейнера и его подконтейнеров. Вы также увидите контейнеры в приложении Docker.
После запуска контейнеров перейдите к http://localhost:3000 в веб-браузере, чтобы получить доступ к веб-странице приложения.
Использование приложения
Интерфейс приложения выглядит так:
В приложении есть четыре отдельных раздела:
· TENSORFLOW MODEL FILES, куда вы загружаете файлы модели и архитектуры TF Keras.
· IMAGES, где вы загружаете изображения, которые хотите объяснить.
· SEGMENTER, где можно настроить параметры трех алгоритмов сегментации, поддерживаемых LIME.
· EXPLAINER, где вы настраиваете параметры для создания объяснений.
Давайте пройдемся по этим разделам и посмотрим, на что способно наше приложение!
Загрузка файлов модели TF
Прежде всего, вам нужно загрузить свою модель на сервер приложения.
Приложение требует две вещи:
· Вес вашей модели в формате .h5.
· Архитектура вашей модели сохранена в файле .json.
Чтобы получить веса вашей модели в формате .h5, запустите этот код после обучения:
И чтобы получить архитектуру модели в файле .json, запустите этот код:
Мы предоставляем файлы для двух моделей — одна обучена на наборе данных MNIST, а другая — на наборе данных CIFAR10. Вы можете найти их в разделе /models/ в каталоге клонированного репозитория.
Вы можете использовать предоставленные нами тестовые файлы или попробовать свои собственные модели. Но для начала используйте файлы, которые мы подготовили.
Чтобы загрузить веса модели, нажмите UPLOADв разделе Model weights и выберите один из .h5файлы в папке /models/.
Чтобы загрузить архитектуру модели, нажмите UPLOADв разделе Model arch и выберите .jsonфайл, соответствующий выбранным весам. Модели имеют схожую архитектуру, но разные входные формы, поэтому они несовместимы друг с другом.
Выбрав оба файла, нажмите Upload model, чтобы отправить файлы на конечную точку API /upload-model/.
Если все в порядке, вы увидите Model loaded!под RESPONSE и код состояния 200 в терминале, из которого вы запускаете приложение.
Загрузка изображений
Затем загрузите изображения, которые вы хотите объяснить в разделе IMAGES.
Мы предоставляем тестовые изображения для каждого из классов цифр MNIST и CIFAR10. Вы можете найти их в разделах /images/mnist/ и /images/cifar10/ соответственно.
Нажмите UPLOAD под Images, перейдите в папку, соответствующую загруженной вами модели, и выберите изображения для загрузки. Затем нажмите Upload images, чтобы отправить файлы изображений на конечную точку API /upload-images/. Если операция прошла успешно, вы увидите Images uploaded! под RESPONSE. Вы также снова увидите код состояния 200 в терминале.
В идеале вы должны загружать изображения для КАЖДОГО доступного класса. Но в этом нет необходимости, если вы просто хотите объяснить одно конкретное изображение.
Обратите внимание, что приложение ожидает изображения JPEG в кодировке uint8. Размер канала должен быть -1. Значения пикселей в изображениях должны находиться в диапазоне от 0 до 255 — они НЕ должны быть нормализованы.
Для справки предоставленные тестовые изображения были сохранены с использованием следующего фрагмента кода Python:
Выбор алгоритма сегментации и настройка его параметров
В качестве следующего шага вы можете настроить алгоритм сегментации.
В разделе SEGMENTER вы можете выбрать один из трех алгоритмов сегментации, поддерживаемых LIME — quickshift, felzenszwalb или slic. Чтобы выбрать алгоритм, щелкните раскрывающийся список под полем Segmenter и выберите сегментатор, который хотите использовать.
Для каждого алгоритма вы можете настроить несколько параметров, чтобы настроить объяснения. Значения по умолчанию подходят для любого из тестов тестового изображения. Однако для других изображений и моделей вам, возможно, придется поиграть с параметрами, чтобы увидеть, что работает лучше всего.
Имейте в виду, что мы не реализовали в нашем приложении некоторые параметры quickshift, felzenszwalb или slic. Подробнее о параметрах этих алгоритмов можно узнать здесь.
Генерация объяснений
Теперь очередь пояснений параметров под EXPLAINER.
Чтобы показать, как параметры влияют на объяснения, давайте сначала попытаемся объяснить число Image indices. Точнее, давайте объясним 5 лучших прогнозов для изображений с индексами 0, 1, 4 и 9 из набора данных MNIST. В случае набора данных MNIST значения, которые вы передаете в Image indices, соответствуют фактическим цифрам на изображениях.
Вот как параметры выглядят в приложении:
Мы перечислили индексы в разделе Image indicesи изменили Top predictionsс 3 на 5. Остальные параметры без изменений. Мы также используем quickshiftс параметрами по умолчанию.
После выбора параметров нажмите Explainв нижней части веб-страницы. Все значения, которые вы ввели в полях SEGMENTERи EXPLAINER, будут отправлены на конечную точку нашего API /explain/.
LIME потребуется некоторое время, чтобы объяснить изображения — если это слишком долго для вас, передайте меньшее значение в Number of samples.
Когда пояснения будут готовы, вы увидите их в поле Explanationsв нижней части веб-страницы.
Вы можете щелкнуть изображение правой кнопкой мыши, а затем нажать Save image as…, чтобы загрузить его в высоком разрешении. Вы также можете открыть изображение в новой вкладке и также просмотреть его в мельчайших деталях.
Далее попробуем объяснить изображение под индексом 2 применительно ко всем меткам. И давайте также отключим positive_only, чтобы видеть как положительные, так и отрицательные стороны в объяснениях.
Объяснение этих параметров будет выглядеть так:
Если вы хотите объяснить только несколько конкретных ярлыков, например, 1, 2, 3, 5, 7, 9 , введите их значения в поле Labels to explain и нажмите Explain. Результат будет выглядеть следующим образом:
Ограничения приложения
В своей текущей реализации приложение имеет некоторые заметные ограничения, в том числе:
· Сообщения об ошибках в приложении крайне ограничены. Вы получаете сообщение Something went wrong! только в том случае, если что-то пойдет не так после того, как вы нажмете одну из кнопок в приложении.
· Приложение поддерживает только модели TF/Keras и поддерживает только изображения JPEG.
· Когда метки для объяснения НЕ None, приложение может генерировать объяснения только для ОДНОГО индекса изображения.
· Единственным этапом предварительной обработки загружаемых изображений является нормализация путем деления значений пикселей на 255,0.
· Не все параметры поддерживаемых алгоритмов сегментации были включены в приложение.
Следующие шаги
Есть много вещей, которые вы могли бы попытаться улучшить в нашем приложении. Вы можете попробовать заменить LIME на SHAP или, может быть, даже добавить SHAP в качестве вторичной структуры объяснения в приложение. Это может быть сложно из-за неполной поддержки SHAP TensorFlow 2, но это должно быть выполнимо.
Кроме того, вы можете добавить в приложение более информативные сообщения об ошибках и добавить поддержку большего количества форматов изображений или типов моделей!
Независимо от того, что вы решите сделать, мы надеемся, что это руководство было для вас полезным и поможет вам начать создавать свои собственные сквозные проекты!
До скорого!
