Монашье заболевание детектив Руководство по использованию искусственного интеллекта в области охраны растений

Искусственный интеллект в охране растений Монашье заболевание детектива руководство по эксплуатации

Введение

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

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

Цели обучения

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

Эта статья была опубликована в рамках Блогонате по науке о данных.

Практическое руководство: создание вашего первого классификатора болезней с Monk

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

Шаг 1: Сбор данных

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

Великолепная команда Plant Village собрала набор данных

1. Загрузите токен API Kaggle:

  • Используйте следующий код для загрузки токена API Kaggle. Данный токен необходим для загрузки наборов данных с Kaggle.
from google.colab import filesfiles.upload()

2. Установите пакет Kaggle Python:

  • Вы должны установить пакет Kaggle Python, чтобы взаимодействовать с Kaggle из вашей среды Colab. Выполните следующую команду:
!pip install kaggle

3. Настройте каталог конфигурации Kaggle:

  • Установите каталог конфигурации Kaggle в “/content” с помощью следующего кода:
import osos.environ['KAGGLE_CONFIG_DIR'] = '/content'

4. Установите соответствующие разрешения:

  • Убедитесь, что файл токена API Kaggle имеет правильные разрешения, выполнив следующую команду:
!chmod 600 /content/kaggle.json

5. Скачайте набор данных:

  • Используйте API Kaggle для загрузки набора данных о болезнях растений, выполните эту команду:
!kaggle datasets download -d "prashantmalge/plant-disease"

6. Разархивируйте набор данных:

  • Наконец, разархивируйте скачанный набор данных с помощью следующей команды:
!unzip plant-disease.zip

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

Шаг 2: Настройка Monk

Во-первых, вам необходимо настроить Monk на вашем локальном компьютере или облачной среде. Следуйте этим шагам, чтобы воспользоваться Monk:

1. Клонируйте репозиторий Monk:

# Клонировать репозиторий Monk!git clone https://github.com/Tessellate-Imaging/monk_v1.git# Добавить репозиторий Monk в путь Pythonimport syssys.path.append("./monk_v1/monk")# Установите любые требуемые пакеты или зависимости, если необходимо# Раскомментируйте и добавьте вашу команду установки здесь# !pip install -r /kaggle/working/monk_v1/installation/requirements_kaggle.txt

2. Установите Monk, используя pip:

!pip install -U monk-colab

Шаг 3: Создайте эксперимент

Теперь давайте создадим эксперимент в Monk. Эксперимент – это структурированная среда, где вы определяете параметры и конфигурации для обучения вашего классификатора болезни. Вот фрагмент кода, чтобы вы могли начать:

from pytorch_prototype import prototype# Создайте экспериментptf = prototype(verbose=1)ptf.Prototype("plant_disease", "exp1")

В этом коде мы назвали наш эксперимент “plant_disease” с тегом “exp1”. Вы можете настроить имена в соответствии с вашим проектом.

Шаг 4: Загрузка данных и предварительная обработка

Загрузите свой набор данных и примените преобразования данных для предварительной обработки. Monk предоставляет удобные функции для загрузки данных и использования преобразований. Вот пример:

# Загрузите набор данных и определите преобразованияptf.Default(dataset_path=["./dataset/train", "./dataset/val"],             model_name="resnet18", freeze_base_network=True, num_epochs=5)

В этом фрагменте мы указываем путь к набору данных и архитектуру модели (ResNet-18) и замораживаем веса базовой сети.

Шаг 5: Быстрый поиск модели

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

# Анализ - 1# Название проекта анализаanalysis_name = "Model_Finder";# Модели для анализа# Первый элемент в списке - название модели# Второй элемент в списке - значение true/false для замораживания базовой сети# Третий элемент в списке - значение true/false для использования предварительно обученной модели в качестве отправной точкиmodels = [["resnet34", True, True], ["resnet50", False, True],           ["densenet121", False, True], ["densenet169", True, True], ["densenet201", True, True]];  # Количество эпох для каждого экспериментаepochs = 5;# Процент исходного набора данных для экспериментапercent_data = 10;# "keep_all" - сохранять все созданные подэксперименты# "keep_non" - удалить все созданные подэкспериментыptf.Analyse_Models(analysis_name, models, percent_data, num_epochs=epochs, state="keep_none"); 
  1. Название проекта анализа: analysis_name – это переменная, которая хранит название аналитического проекта. В этом случае он установлен на “Model_Finder”.
  2. Модели для анализа: список models указывает модели, которые вы хотите проанализировать. Каждая модель представлена в виде списка с тремя элементами:
  3. Количество эпох: количество эпох, которое вы хотите запустить для каждого эксперимента. В этом случае установлено значение 5.
  4. Процент исходного набора данных: percent_data указывает процент исходного набора данных, который будет использоваться для экспериментов. Здесь установлено значение 10%, что означает использование только 10% набора данных.
  5. Состояние: параметр состояния определяет, сохранять или удалять подэксперименты. Если установлено значение “keep_none”, подэксперименты не будут сохранены, и будут сохранены только окончательные результаты.
  6. Анализ_Моделей: Наконец, функция ptf.Analyse_Models() вызывается с указанными параметрами для выполнения анализа моделей. Он будет запускать эксперименты для каждой модели и записывать результаты.

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

Вывод:

Шаг 6: Обновление модели

## Обновление архитектуры моделиptf.update_model_name("densenet121");ptf.update_freeze_base_network(True);ptf.update_use_pretrained(True);ptf.Reload();
  1. Обновление названия модели: ptf.update_model_name(“densenet121”) обновляет архитектуру модели на “densenet121”. Это означает, что вы переключаетесь с ранее использованной модели на DenseNet-121.
  2. Обновление замороженной базовой сети: ptf.update_freeze_base_network(True) устанавливает флаг для замораживания базовой сети на “True”. Заморозка базовой сети означает, что предварительно обученные слои модели не будут обновляться во время обучения. Они останутся фиксированными, и будут обучаться только дополнительные слои (если они есть). Это может быть полезно при использовании предварительно обученных моделей для передачи обучения.
  3. Обновление использования предобученной модели: ptf.update_use_pretrained(True) устанавливает флаг использования предварительно обученных весов на “True”. Это указывает, что вы хотите инициализировать модель с использованием предварительно обученных весов. Использование предварительно обученных весов в качестве отправной точки для передачи обучения является общей практикой, особенно при переходе к новой архитектуре модели, такой как DenseNet-121.
  4. Перезагрузка: ptf.Reload() перезагружает модель с обновленными конфигурациями. После изменения архитектуры модели и ее настроек необходимо перезагрузить модель, чтобы применить эти изменения.

Вкратце, данный код переключает архитектуру модели на DenseNet-121, замораживает базовую сеть и использует предобученные веса. Затем эти изменения применяются к модели путем ее повторной загрузки.

Вывод:

Шаг 7: Найти подходящий размер пакета

#Анализ - 2# Название проекта анализаanalysis_name = "Поиск размера пакета";# Размеры пакетов для исследованияbatch_sizes = [4, 8, 16, 32];# Количество эпох для каждого экспериментаepochs = 10;# Процент оригинального набора данных для использования в экспериментахpercent_data = 10;# "keep_all" - Сохранить все созданные подэксперименты# "keep_non" - Удалить все созданные подэксперименты   ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data,                         num_epochs=epochs, state="keep_none"); 
  1. Название анализа: analysis_name = “Поиск размера пакета” определяет название вашего анализа, которое в данном случае является “Поиск размера пакета”. Это название помогает вам определить цель данного анализа.
  2. Размеры пакетов для исследования: batch_sizes = [4, 8, 16, 32] перечисляет разные размеры пакетов, которые вы хотите исследовать во время анализа. В этом примере вы рассматриваете размеры пакетов 4, 8, 16 и 32.
  3. Количество эпох: epochs = 10 указывает количество эпох обучения для каждого эксперимента во время анализа. Каждый эксперимент будет работать в течение десяти эпох, чтобы оценить производительность модели с разными размерами пакетов.
  4. Процент оригинального набора данных: percent_data = 10 определяет процент оригинального набора данных, который вы хотите использовать для экспериментов. В данном случае вы используете 10% от набора данных.
  5. Состояние: state = “keep_none” определяет состояние созданных подэкспериментов во время анализа. В данном случае “keep_none” означает, что вы не хотите сохранять подэксперименты, созданные во время данного анализа. Они будут удалены после завершения исследования.
  6. Анализ размеров пакетов: ptf.Analyse_Batch_Sizes(analysis_name, batch_sizes, percent_data, num_epochs=epochs, state = “keep_none”) инициирует анализ размера пакета. Эта функция будет запускать эксперименты с разными размерами пакетов (4, 8, 16 и 32), чтобы оценить их влияние на производительность модели.

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

Вывод:

Шаг 8: Обновление размера пакета

## Обновление размера пакетаptf.update_batch_size(8);ptf.Reload();
  1. Обновление размера пакета: ptf.update_batch_size(8) обновляет размер пакета вашей модели на 8. Это означает, что ваша модель будет обрабатывать данные порциями по восемь образцов в каждом пакете во время обучения. Размер пакета является гиперпараметром, который может влиять на скорость обучения модели, использование памяти и сходимость.
  2. Повторная загрузка: ptf.Reload() перезагружает модель с обновленным размером пакета. Данная операция необходима, поскольку изменение размера пакета может повлиять на требования к памяти для вашей модели, и повторная загрузка гарантирует, что модель настроена правильно с новым размером пакета.

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

Вывод:

Шаг 9: Найти правильные входные размеры

#Анализ - 3# Название проекта анализаanalysis_name = "Поиск размера входа";# Размеры входных данных для исследования  input_sizes = [224, 256, 512];# Количество эпох для каждого экспериментаepochs=5;# Процент оригинального набора данных для использования в экспериментахpercent_data=10;# "keep_all" - Сохранить все созданные подэксперименты# "keep_non" - Удалить все созданные подэксперименты    ptf.Analyse_Input_Sizes(analysis_name, input_sizes, percent_data,                         num_epochs=epochs, state="keep_none"); 
  1. Название проекта анализа: analysis_name = “Input_Size_Finder” определяет имя проекта анализа, используемое для организации и маркировки экспериментов, связанных с размером ввода.
  2. Размеры ввода для исследования: input_sizes = [224, 256, 512] указывает список размеров ввода (размеры изображений), которые вы хотите исследовать. Вы проверяете три разных размера ввода: 224×224, 256×256 и 512×512 пикселей.
  3. Число эпох: эпохи = пять устанавливают количество эпох обучения для каждого эксперимента. В этом случае вы обучаете модель в течение пяти эпох для каждого размера ввода.
  4. Процент исходного набора данных: percent_data = 10 указывает процент исходного набора данных, который будет использован для экспериментов. Использование меньшей части набора данных может помочь ускорить анализ, сохраняя при этом понимание того, как различные размеры ввода влияют на производительность модели.
  5. Статус: state=”keep_none” указывает, что вы хотите сохранить только наиболее успешный эксперимент и отказаться от других. Это полезно для эффективного определения оптимального размера ввода без захламления вашего рабочего пространства множеством экспериментов.

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

Выходные данные:

Шаг 10: Обновление размера ввода

## Обновление размера вводаptf.update_input_size(224);ptf.Reload();
  1. Обновление размера ввода: ptf.update_input_size(224) устанавливает размер ввода вашей модели в 224×224 пикселей. Это означает, что ваша модель ожидает, что входные изображения будут иметь размеры 224 пикселя в ширину и 224 пикселя в высоту. Изменение размера ввода может значительно влиять на производительность и время обучения модели.
  2. Перезагрузка: ptf.Reload() перезагружает модель с обновленным размером ввода. Этот шаг необходим, потому что изменение размера ввода требует модификации архитектуры модели. Перезагрузка гарантирует, что модель правильно настроена с новым размером ввода.

<p, p="" быть="" ваша="" вашим="" ввода="" во="" время="" выбор="" вывода="" гиперпараметром="" готова="" данных="" для="" должен="" достижения="" задачи="" и="" изображения="" критическим="" модель="" набором="" обучения="" означает,="" оптимальных="" принимать="" размера="" результатов.="" результатов.

Выходные данные:

Шаг 11: Определение правильного начального значения скорости обучения

#Анализ - 4 #Название проекта анализаanalysis_name = "Learning_Rate_Finder" #Скорости обучения для исследованияlrs = [0.01, 0.005, 0.001, 0.0001]; #Число эпох для каждого экспериментаepochs=5 #Процент исходного набора данных для использования в экспериментахpercent_data=10 #"keep_all" - Сохранить все созданные подэксперименты#"keep_non" - Удалить все созданные подэкспериментыptf.Analyse_Learning_Rates(analysis_name, lrs, percent_data, num_epochs=epochs, state="keep_none"); 
  1. Название проекта анализа: analysis_name = “Learning_Rate_Finder” задает название вашего проекта анализа скорости обучения. Вы будете использовать это имя для организации результатов ваших экспериментов.
  2. Скорости обучения для исследования: lrs = [0.01, 0.005, 0.001, 0.0001] указывает список скоростей обучения, которые вы хотите исследовать во время анализа. Скорость обучения является важным гиперпараметром при обучении глубоких нейронных сетей, и правильный выбор скорости обучения может значительно влиять на успех обучения.
  3. Число эпох: эпохи = 5 определяет количество эпох (итераций обучения), на которых запускаются эксперименты с разными скоростями обучения. Это помогает определить, насколько быстро модель сходится с разными скоростями обучения.
  4. Процент исходного набора данных: percent_data = 10 определяет процент исходного набора данных, который будет использоваться для экспериментов. Использование меньшего подмножества данных может ускорить анализ, при этом сохраняя информацию.
  5. “keep_all” или “keep_none”: state=”keep_none” определяет, сохранять или удалять все созданные подэксперименты во время анализа скорости обучения. В данном случае “keep_none” означает, что подэксперименты не будут сохранены, вероятно, потому что основная цель – определить наилучшую скорость обучения, а не сохранять промежуточные результаты.

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

Вывод:

Шаг 12: Обновление скорости обучения

## Обновление скорости обученияptf.update_learning_rate(0.01);ptf.Reload();
  1. Обновление скорости обучения: ptf.update_learning_rate(0.01) обновляет скорость обучения до 0.01. Скорость обучения является гиперпараметром, который управляет шагом оптимизации. Она определяет, насколько обновляются параметры модели во время каждой итерации обучения.
  2. Перезагрузка: ptf.Reload() перезагружает модель с обновленной скоростью обучения. Перезагрузка модели гарантирует, что изменения скорости обучения будут применены во время последующих сеансов обучения.

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

Вывод:

Шаг 13: Поиск оптимизатора

# Анализ - 5# Название проекта анализаanalysis_name = "Optimiser_Finder";# Оптимизаторы для исследованияoptimizers = ["sgd", "adam", "adamax", "rmsprop"];   # Имя модели, скорость обучения# Количество эпох для каждого экспериментаepochs = 5;# Процент оригинального набора данных, который используется для экспериментированияpercent_data = 10;# "keep_all" - хранит все созданные подэксперименты# "keep_none" - удаляет все созданные подэкспериментыptf.Analyse_Optimizers(analysis_name, optimizers, percent_data,                        num_epochs=epochs, state="keep_none"); 
  1. Название проекта анализа: analysis_name = “Optimiser_Finder”; определяет имя проекта анализа как “Optimiser_Finder”. Этот проект будет направлен на поиск оптимального оптимизатора для вашей модели.
  2. Оптимизаторы для исследования: optimizers – это список, содержащий имена оптимизаторов, которые будут исследоваться. Среди оптимизаторов есть “sgd”, “adam”, “adamax” и “rmsprop”. Каждый оптимизатор имеет свой набор техник оптимизации и гиперпараметров.
  3. Количество эпох: epochs = 5; указывает количество эпох для каждого эксперимента во время анализа. Эпоха представляет собой один полный проход по всему набору данных для обучения.
  4. Процент оригинального набора данных: percent_data = 10; определяет процент использования оригинального набора данных для экспериментирования. В данном случае будет использовано 10% набора данных.
  5. Analyse_Optimizers: ptf.Analyse_Optimizers(analysis_name, optimizers, percent_data, num_epochs=epochs, state=”keep_none”); запускает анализ различных оптимизаторов. Он будет выполнять эксперименты с использованием каждого оптимизатора из списка optimizers и записывать результаты.

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

Вывод:

Шаг 14: Обновление оптимизатора

## Обновление имени оптимизаторапtf.optimizer_adamax(0.001);ptf.Reload();
  1. Обновление имени оптимизатора: ptf.optimizer_adamax(0.001); устанавливает оптимизатор “Adamax” с коэффициентом обучения 0.001.
  2. Перезагрузка модели: ptf.Reload(); перезагружает модель с новой конфигурацией оптимизатора.

Вы меняете алгоритм оптимизации, используемый во время обучения, обновляя оптимизатор до “Adamax” с определенной скоростью обучения. Разные оптимизаторы могут сходиться с разной скоростью, что приводит к различиям в процессе обучения и производительности конечной модели. Обычно экспериментируют с другими оптимизаторами и скоростями обучения, чтобы найти наилучшую комбинацию для конкретной задачи глубокого обучения.

Шаг 15: Установка промежуточного состояния – сохранение в False

ptf.update_save_intermediate_models(False);
  • ptf: Относится к объекту PyTorch Prototype, который вы создали.
  • update_save_intermediate_models(False): Эта функция обновляет настройки сохранения промежуточных моделей во время обучения. Вы отключаете возможность сохранять промежуточные модели, передавая False в качестве аргумента.

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

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

Далее мы создаем новый эксперимент, используя ‘copy_experiment’ и возобновляем обучение для достижения дальнейшего улучшения.

ptf = prototype(verbose=1);ptf.Prototype("поражение растений", "эксперимент2", copy_from=["поражение растений", "эксперимент1"]);
  1. ptf = prototype(verbose=1);: Вы создаете новый объект Prototype с именем ptf с включенным режимом вывода. Этот объект позволяет вам определять и управлять экспериментами машинного обучения.
  2. ptf.Prototype(“поражение растений”, “эксперимент2”, copy_from=[“поражение растений”, “эксперимент1”]);: Эта строка указывает детали нового эксперимента:

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

Суммарная конфигурация эксперимента:

ptf.Summary()

Вывод:

Шаг 16: Сравнение

Monk предоставляет упрощенную функцию “Сравнение”, которая собирает статистику, визуализирует результаты и помогает пользователям определить, какие архитектуры моделей и гиперпараметры наиболее эффективны. Этот шаг помогает в итеративном процессе настройки моделей и постепенного улучшения их производительности, в конечном итоге помогая выбрать наиболее эффективные конфигурации моделей для развертывания.

from compare_prototype import comparectf = compare(verbose=1);ctf.Comparison("поражение растений");ctf.Add_Experiment("поражение растений", "эксперимент1");ctf.Add_Experiment("поражение растений", "эксперимент2");

Эти фрагменты кода демонстрируют использование модуля “compare_prototype” в Monk. Сначала он импортирует необходимую функцию “compare”. Затем инициализирует объект сравнения “ctf” с установленной вербозностью 1 для отчетности. Сравнение названо “поражение растений” с использованием ctf.Comparison.

После этого два эксперимента “эксперимент1” и “эксперимент2”, проведенные в проекте “поражение растений”, добавляются к сравнению с помощью ctf.Add_Experiment. Это позволяет пользователям анализировать и сравнивать результаты, метрики и производительность этих двух экспериментов для принятия информированных решений по выбору и настройке модели.

Шаг 17: Вывод

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

import numpy as npimport PIL.Image as Imageimport requeststest_url = "https://gardenerspath.com/wp-content/uploads/2019/08/            Frogeye-spots-Botryosphaeria-obtusa-on-apple-leaf-FB.jpg"# URL изображения для загрузки определена как image_url r = requests.get(test_url) # создание объекта HTTP-ответа with open('test.jpg','wb') as f:     f.write(r.content) test = Image.open('./test.jpg')test

Вывод:

ptf.Prototype("поражение растений", "эксперимент2", eval_infer=True);
  • ptf.Prototype(“поражение растений”, “эксперимент2”, eval_infer=True);: Эта строка настраивает новый эксперимент с именем “эксперимент2” в рамках проекта “поражение растений” с использованием функции Prototype Monk. Она также включает режим оценки и вывода (eval_infer=True), указывающий, что этот эксперимент будет использоваться для предсказания на новых данных.

Вывод:

  1. Подробности модели: После инициализации эксперимента, код загружает предварительно обученную модель. В данном случае, загружается модель из директории “workspace/plant_disease/exp2/output/models/final”. Эта модель будет использоваться для вывода.
  2. Подробности эксперимента: Этот раздел содержит информацию об эксперименте, включая название проекта (“plant_disease”), название эксперимента (“exp2”), и директорию, в которой хранится эксперимент

Шаг 18: Предсказание

img_name = "test.jpg";predictions = ptf.Infer(img_name=img_name, return_raw=True);print(predictions)
  1. img_name = “test.jpg”;: Эта строка указывает имя файла изображения (“test.jpg”), для которого вы хотите выполнить вывод. Вы можете заменить “test.jpg” на путь к изображению, которое вы хотите проанализировать.
  2. Predictions = ptf.Infer(img_name=img_name, return_raw=True);: Эта строка кода вызывает функцию “Infer”, предоставленную экспериментом Monk (ptf), для выполнения предсказаний на указанном изображении. Она принимает имя файла изображения и запрашивает сырые оценки предсказаний, устанавливая “return_raw=True”. Это означает, что она будет возвращать сырые числовые оценки для каждого класса.
  3. print(predictions): Наконец, код выводит предсказания. Эти предсказания обычно включают информацию, такую как предсказанный класс и связанные с ним сырые оценки для каждого класса.

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

import csvdef read_labels():    mydict = {}    with open('./dataset/labels.csv', mode='r') as infile:        reader = csv.reader(infile)        with open('labels_new.csv', mode='w') as outfile:            writer = csv.writer(outfile)            mydict = {rows[0]:rows[1] for rows in reader}    return mydictdef predict_label(predictions):    pred_class = predictions['predicted_class']    label_dict = read_labels()    out_label = label_dict[pred_class]    return out_labelprint("Предсказанный класс для тестового изображения: {}".format(predict_label(predictions)))
  1. Функция read_labels(): Эта функция читает информацию о метках из файла “labels.csv”. Она открывает CSV-файл, считывает его содержимое и создает словарь (mydict), где ключи – это идентификаторы классов, а значения – соответствующие метки. Затем она записывает эту информацию о метках в новый файл CSV с названием “labels_new.csv”.
  2. Функция predict_label(predictions): Эта функция принимает предсказания, полученные из предыдущего вывода, в качестве входных данных. Она извлекает предсказанный идентификатор класса из предсказаний и использует ранее созданный словарь меток для нахождения соответствующей метки. Затем метка возвращается как out_label.
  3. Печать результата: Код вызывает функцию predict_label(predictions), чтобы получить метку, связанную с предсказанным классом, и выводит ее как “Предсказанный класс для тестового изображения: “.

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

Вывод: Предсказанный класс для тестового изображения: Apple___Black_rot

Продвинутые техники классификации заболеваний растений

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

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

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

# Файн-тюнинг предварительно обученной модели с помощью пользовательских данныхptf.update_model_name("resnet50")ptf.update_freeze_base_network(False)  # Размораживаем базовую сеть для донастройкиptf.update_use_pretrained(True)ptf.Reload()ptf.Train()

2. Увеличение данных

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

# Применить преобразования для аугментации данных
ptf.apply_random_rotation(train=True, val=True)
ptf.apply_random_crop(scale=[0.8, 1.0], ratio=[0.8, 1.2], train=True)
ptf.apply_random_brightness(train=True)

3. Обработка дисбаланса классов

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

# Используйте функцию потерь с учетом весов классов
ptf.loss_weighted_softmax_crossentropy(class_weights)

4. Ансамблевое обучение

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

# Создайте ансамбль моделей
ensemble = ptf.create_ensemble(models)
ensemble.Train()

5. Настройка гиперпараметров

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

# Настройка гиперпараметров - скорость обучения, размер пакета, оптимизатор
ptf.Analyse_Learning_Rates("LR_Finder", lrs, percent_data=10, num_epochs=5)
ptf.Analyse_Batch_Sizes("Batch_Size_Finder", batch_sizes, percent_data=10, num_epochs=5)
ptf.Analyse_Optimizers("Optimizer_Finder", optimizers, percent_data=10, num_epochs=5)

6. Интерпретируемость модели

Понимание причин, по которым модель делает определенные прогнозы, является важным, особенно в критических приложениях, таких как классификация болезней. Monk предоставляет средства интерпретируемости, такие как Grad-CAM (Gradient-weighted Class Activation Mapping), для визуализации наиболее влиятельных областей изображения для прогноза.

# Визуализация прогнозов модели с помощью Grad-CAM
heatmap = ptf.Visualize_With_GradCAM(image_path, target_layer)

Заключение

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

Основные выводы:

  1. Monk упрощает глубокое обучение: Monk предоставляет удобный интерфейс для создания, обучения и развертывания моделей глубокого обучения. Его модульный подход позволяет даже начинающим легко погрузиться в компьютерное зрение.
  2. Раннее обнаружение болезней: Болезни растений могут уничтожить урожай и угрожать продовольственной безопасности. Модели на основе Monk позволяют обнаружить болезни на ранней стадии, помогая фермерам принимать меры по защите культур.
  3. Точное сельское хозяйство: Monk способствует точному сельскому хозяйству путем оптимизации использования ресурсов, снижения химических внесений и увеличения урожайности. Фермеры могут достигать более высокой прибыльности и экологической устойчивости.
  4. Влияние на реальный мир: Приложения Monk выходят за пределы сельского хозяйства и затрагивают исследования, охрану природы и гражданскую науку. Оно дает возможность отдельным лицам и организациям положительно влиять на здоровье растений и экосистемы.

Ресурсы для дальнейшего изучения

Чтобы погрузиться глубже в классификацию болезней растений с помощью Monk, вот несколько полезных ресурсов:

<!–Монк остается на переднем крае решений по классификации болезней растений. Его простой в использовании интерфейс и мощные возможности позволяют физическим и организациям вносить вклад в благополучие экосистем планеты и глобальной продовольственной базы.

Часто задаваемые вопросы

Передаваемые в статье материалы не являются собственностью Analytics Vidhya и используются по усмотрению автора.