cropnet_on_device.ipynb

Kernel: Python 3

Copyright 2021 The TensorFlow Hub Authors.

Licensed under the Apache License, Version 2.0 (the "License");

#@title Copyright 2021 The TensorFlow Hub Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ==============================================================================

식물 질병 감지를 위한 미세 조정 모델

TensorFlow.org에서 보기

Google Colab에서 실행하기

GitHub에서 소스 보기

노트북 다운로드하기

TF Hub 모델보기

이 노트북은 TFDS의 데이터 세트 또는 농작물 질병 감지 데이터세트에서 TensorFlow Hub의 CropNet 모델을 미세 조정하는 방법을 보여줍니다.

이를 통해 다음을 수행할 수 있습니다.

• TFDS 카사바 데이터세트 또는 자체 데이터 로드

• 더 강력한 모델을 얻기 위해 알려지지 않은(음성) 예제로 데이터 보강

• 데이터에 이미지 강화 적용

• TF Hub에서 CropNet 모델 로드 및 미세 조정

• 작업 라이브러리, MLKit 또는 TFLite를 사용하여 앱에 직접 배포할 준비가 된 TFLite 모델 내보내기

가져오기 및 종속성

시작하기 전에 Model Maker 및 최신 버전의 TensorFlow Datasets와 같이 필요한 일부 종속성을 설치해야 합니다.

!sudo apt install -q libportaudio2
## image_classifier library requires numpy <= 1.23.5
!pip install "numpy<=1.23.5"
!pip install --use-deprecated=legacy-resolver tflite-model-maker-nightly
!pip install -U tensorflow-datasets
## scann library requires tensorflow < 2.9.0
!pip install "tensorflow<2.9.0"
!pip install "tensorflow-datasets~=4.8.0"  # protobuf>=3.12.2
!pip install tensorflow-metadata~=1.10.0  # protobuf>=3.13
## tensorflowjs requires packaging < 20.10
!pip install "packaging<20.10"

import matplotlib.pyplot as plt
import os
import seaborn as sns

import tensorflow as tf
import tensorflow_datasets as tfds

from tensorflow_examples.lite.model_maker.core.export_format import ExportFormat
from tensorflow_examples.lite.model_maker.core.task import image_preprocessing

from tflite_model_maker import image_classifier
from tflite_model_maker import ImageClassifierDataLoader
from tflite_model_maker.image_classifier import ModelSpec

미세 조정할 TFDS 데이터세트 로드

TFDS에서 공개적으로 사용 가능한 카사바 잎 질병 데이터세트를 사용하도록 하겠습니다.

tfds_name = 'cassava'
(ds_train, ds_validation, ds_test), ds_info = tfds.load(
    name=tfds_name,
    split=['train', 'validation', 'test'],
    with_info=True,
    as_supervised=True)
TFLITE_NAME_PREFIX = tfds_name

또는 미세 조정할 자체 데이터 대체 로드

TFDS 데이터세트를 사용하는 대신 자체 데이터로 훈련할 수도 있습니다. 이 코드 스니펫은 사용자 정의 데이터세트를 로드하는 방법을 보여줍니다. 지원되는 데이터 구조는 이 링크를 참조하십시오. 다음에는 공개적으로 사용 가능한 카사바 잎 질병 데이터세트를 사용한 예가 제공되어 있습니다.

# data_root_dir = tf.keras.utils.get_file(
#     'cassavaleafdata.zip',
#     'https://storage.googleapis.com/emcassavadata/cassavaleafdata.zip',
#     extract=True)
# data_root_dir = os.path.splitext(data_root_dir)[0]  # Remove the .zip extension

# builder = tfds.ImageFolder(data_root_dir)

# ds_info = builder.info
# ds_train = builder.as_dataset(split='train', as_supervised=True)
# ds_validation = builder.as_dataset(split='validation', as_supervised=True)
# ds_test = builder.as_dataset(split='test', as_supervised=True)

훈련 분할에서 샘플 시각화

이미지 샘플 및 해당 레이블에 대한 클래스 ID와 클래스 이름을 포함하는 데이터세트의 몇 가지 예를 살펴보겠습니다.

_ = tfds.show_examples(ds_train, ds_info)

TFDS 데이터세트에서 알 수 없는 예시로 사용할 이미지 추가

학습 데이터세트에 알 수 없는(음성) 예제를 추가하고 알 수 없는 새 클래스 레이블 번호를 할당합니다. 예를 들어 실제로 현장에서 사용될 때 예상치 못한 것을 볼 때 "알 수 없음"을 예측하는 옵션이 있는 모델을 보유하기 위함입니다.

아래에서 알 수 없는 추가 이미지를 샘플링하는 데 사용할 데이터세트 목록을 볼 수 있습니다. 다양성을 높이기 위해 전혀 다른 3개의 데이터세트가 포함되어 있습니다. 그 중 하나는 콩 잎 질병 데이터세트이므로 해당 모델은 카사바 이외의 병든 식물에 노출됩니다.

UNKNOWN_TFDS_DATASETS = [{
    'tfds_name': 'imagenet_v2/matched-frequency',
    'train_split': 'test[:80%]',
    'test_split': 'test[80%:]',
    'num_examples_ratio_to_normal': 1.0,
}, {
    'tfds_name': 'oxford_flowers102',
    'train_split': 'train',
    'test_split': 'test',
    'num_examples_ratio_to_normal': 1.0,
}, {
    'tfds_name': 'beans',
    'train_split': 'train',
    'test_split': 'test',
    'num_examples_ratio_to_normal': 1.0,
}]

UNKNOWN 데이터세트도 TFDS에서 로드됩니다.

# Load unknown datasets.
weights = [
    spec['num_examples_ratio_to_normal'] for spec in UNKNOWN_TFDS_DATASETS
]
num_unknown_train_examples = sum(
    int(w * ds_train.cardinality().numpy()) for w in weights)
ds_unknown_train = tf.data.Dataset.sample_from_datasets([
    tfds.load(
        name=spec['tfds_name'], split=spec['train_split'],
        as_supervised=True).repeat(-1) for spec in UNKNOWN_TFDS_DATASETS
], weights).take(num_unknown_train_examples)
ds_unknown_train = ds_unknown_train.apply(
    tf.data.experimental.assert_cardinality(num_unknown_train_examples))
ds_unknown_tests = [
    tfds.load(
        name=spec['tfds_name'], split=spec['test_split'], as_supervised=True)
    for spec in UNKNOWN_TFDS_DATASETS
]
ds_unknown_test = ds_unknown_tests[0]
for ds in ds_unknown_tests[1:]:
  ds_unknown_test = ds_unknown_test.concatenate(ds)

# All examples from the unknown datasets will get a new class label number.
num_normal_classes = len(ds_info.features['label'].names)
unknown_label_value = tf.convert_to_tensor(num_normal_classes, tf.int64)
ds_unknown_train = ds_unknown_train.map(lambda image, _:
                                        (image, unknown_label_value))
ds_unknown_test = ds_unknown_test.map(lambda image, _:
                                      (image, unknown_label_value))

# Merge the normal train dataset with the unknown train dataset.
weights = [
    ds_train.cardinality().numpy(),
    ds_unknown_train.cardinality().numpy()
]
ds_train_with_unknown = tf.data.Dataset.sample_from_datasets(
    [ds_train, ds_unknown_train], [float(w) for w in weights])
ds_train_with_unknown = ds_train_with_unknown.apply(
    tf.data.experimental.assert_cardinality(sum(weights)))

print((f"Added {ds_unknown_train.cardinality().numpy()} negative examples."
       f"Training dataset has now {ds_train_with_unknown.cardinality().numpy()}"
       ' examples in total.'))

강화 적용

모든 이미지를 다양하게 만들기 위해 다음 변경 사항 같은 몇 가지 강화 기능을 적용합니다.

• 밝기

• 대비

• 포화

• 색조

• 절단

이러한 유형의 강화 기능은 모델을 이미지 입력의 변화에 대해 더 강력하게 만드는 데 도움이 됩니다.

def random_crop_and_random_augmentations_fn(image):
  # preprocess_for_train does random crop and resize internally.
  image = image_preprocessing.preprocess_for_train(image)
  image = tf.image.random_brightness(image, 0.2)
  image = tf.image.random_contrast(image, 0.5, 2.0)
  image = tf.image.random_saturation(image, 0.75, 1.25)
  image = tf.image.random_hue(image, 0.1)
  return image


def random_crop_fn(image):
  # preprocess_for_train does random crop and resize internally.
  image = image_preprocessing.preprocess_for_train(image)
  return image


def resize_and_center_crop_fn(image):
  image = tf.image.resize(image, (256, 256))
  image = image[16:240, 16:240]
  return image


no_augment_fn = lambda image: image

train_augment_fn = lambda image, label: (
    random_crop_and_random_augmentations_fn(image), label)
eval_augment_fn = lambda image, label: (resize_and_center_crop_fn(image), label)

강화 기능을 적용하기 위해 Dataset 클래스의 map 메소드를 사용합니다.

ds_train_with_unknown = ds_train_with_unknown.map(train_augment_fn)
ds_validation = ds_validation.map(eval_augment_fn)
ds_test = ds_test.map(eval_augment_fn)
ds_unknown_test = ds_unknown_test.map(eval_augment_fn)

데이터를 Model Maker 친화적인 형식으로 래핑

Model Maker와 함께 이러한 데이터세트를 사용하려면 데이터세트가 ImageClassifierDataLoader 클래스에 있어야 합니다.

label_names = ds_info.features['label'].names + ['UNKNOWN']

train_data = ImageClassifierDataLoader(ds_train_with_unknown,
                                       ds_train_with_unknown.cardinality(),
                                       label_names)
validation_data = ImageClassifierDataLoader(ds_validation,
                                            ds_validation.cardinality(),
                                            label_names)
test_data = ImageClassifierDataLoader(ds_test, ds_test.cardinality(),
                                      label_names)
unknown_test_data = ImageClassifierDataLoader(ds_unknown_test,
                                              ds_unknown_test.cardinality(),
                                              label_names)

훈련 실행하기

TensorFlow Hub에는 전이 학습에 사용할 수 있는 여러 가지 모델이 있습니다.

여기에서 하나를 선택할 수 있으며 더 나은 결과를 얻기 위해 다른 것들을 계속 실험할 수도 있습니다.

더 많은 모델을 시도하고 싶다면 이 컬렉션에서 추가할 수 있습니다.

#@title Choose a base model

model_name = 'mobilenet_v3_large_100_224'  #@param ['cropnet_cassava', 'cropnet_concat', 'cropnet_imagenet', 'mobilenet_v3_large_100_224']

map_model_name = {
    'cropnet_cassava':
        'https://tfhub.dev/google/cropnet/feature_vector/cassava_disease_V1/1',
    'cropnet_concat':
        'https://tfhub.dev/google/cropnet/feature_vector/concat/1',
    'cropnet_imagenet':
        'https://tfhub.dev/google/cropnet/feature_vector/imagenet/1',
    'mobilenet_v3_large_100_224':
        'https://tfhub.dev/google/imagenet/mobilenet_v3_large_100_224/feature_vector/5',
}

model_handle = map_model_name[model_name]

모델을 미세 조정하기 위해 Model Maker를 사용합니다. 이렇게 하면 모델을 훈련한 후 TFLite로 변환하기 때문에 전체 솔루션이 더 쉬워집니다.

Model Maker는 나중에 기기에 모델을 쉽게 배포하는 데 필요한 모든 정보를 사용하여 이러한 변환을 최상의 상태로 만듭니다.

모델 사양은 Model Maker에 사용하려는 기본 모델을 알려주는 방법입니다.

image_model_spec = ModelSpec(uri=model_handle)

여기서 중요한 세부 사항 중 하나는 훈련 중에 기본 모델을 미세 조정하도록 train_whole_model을 설정하는 것입니다. 이로 인해 프로세스가 느려지지만 최종 모델의 정확도는 더 높아집니다. shuffle을 설정하면 무작위로 섞인 순서로 데이터를 볼 수 있습니다. 이는 모델 학습을 위한 모범 사례입니다.

model = image_classifier.create(
    train_data,
    model_spec=image_model_spec,
    batch_size=128,
    learning_rate=0.03,
    epochs=5,
    shuffle=True,
    train_whole_model=True,
    validation_data=validation_data)

테스트 분할에서 모델 평가하기

model.evaluate(test_data)

미세 조정된 모델을 더 잘 이해하려면 혼동 행렬을 분석하는 것이 좋습니다. 이것은 한 클래스가 다른 클래스로 예측되는 빈도를 보여줍니다.

def predict_class_label_number(dataset):
  """Runs inference and returns predictions as class label numbers."""
  rev_label_names = {l: i for i, l in enumerate(label_names)}
  return [
      rev_label_names[o[0][0]]
      for o in model.predict_top_k(dataset, batch_size=128)
  ]

def show_confusion_matrix(cm, labels):
  plt.figure(figsize=(10, 8))
  sns.heatmap(cm, xticklabels=labels, yticklabels=labels, 
              annot=True, fmt='g')
  plt.xlabel('Prediction')
  plt.ylabel('Label')
  plt.show()

confusion_mtx = tf.math.confusion_matrix(
    list(ds_test.map(lambda x, y: y)),
    predict_class_label_number(test_data),
    num_classes=len(label_names))

show_confusion_matrix(confusion_mtx, label_names)

알 수 없는 테스트 데이터에서 모델 평가하기

이 평가에서 우리는 모델이 거의 1의 정확도를 가질 것으로 예상합니다. 모델이 테스트된 모든 이미지는 일반 데이터세트와 관련이 없으므로 모델이 "알 수 없는" 클래스 레이블을 예측할 것으로 예상합니다.

model.evaluate(unknown_test_data)

혼동 행렬을 인쇄합니다.

unknown_confusion_mtx = tf.math.confusion_matrix(
    list(ds_unknown_test.map(lambda x, y: y)),
    predict_class_label_number(unknown_test_data),
    num_classes=len(label_names))

show_confusion_matrix(unknown_confusion_mtx, label_names)

모델을 TFLite 및 SavedModel로 내보내기

이제 기기에 배포하고 TensorFlow에서 추론에 사용하기 위해 훈련된 모델을 TFLite 및 SavedModel 형식으로 내보낼 수 있습니다.

tflite_filename = f'{TFLITE_NAME_PREFIX}_model_{model_name}.tflite'
model.export(export_dir='.', tflite_filename=tflite_filename)

# Export saved model version.
model.export(export_dir='.', export_format=ExportFormat.SAVED_MODEL)

다음 단계

방금 훈련한 모델을 모바일 기기에서 사용하고 현장에 배포할 수도 있습니다!

모델을 다운로드하려면 colab 왼쪽에 있는 파일 메뉴의 폴더 아이콘을 클릭하고 다운로드 옵션을 선택하십시오.

여기에 사용된 동일한 기술을 사용 사례 또는 다른 유형의 이미지 분류 작업에 더 적합할 수 있는 다른 식물 질병 작업에 적용할 수 있습니다. Android 앱에서 후속 작업을 수행하고 배포하려는 경우 이 Android 빠른 시작 가이드에서 계속 진행할 수 있습니다.