Automatic Image Classification Generator позволяет выполнять автоматический сбор данных, автоматизацию обучения и тестирования моделей машинного обучения. Благодаря использованию API SerpApi’s Google Images Scraper, инструмент позволяет обойти необходимость ручного ввода данных и сократить количество человеческих ошибок, обеспечивая функциональность предварительной обработки в рабочем процессе.

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

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

Каковы преимущества автоматизированного сбора данных?

Программное обеспечение использует API Google Images от SerpApi для автоматизированного сбора данных изображений, которые будут использоваться в обучении и тестировании моделей машинного обучения, минуя необходимые ручные процессы. Для получения дополнительной информации о системах автоматизированного сбора данных в реальном времени для создания наборов данных в других форматах, таких как SerpApi’s Google Scholar Scraper API для автоматизации тематических исследований или других случаев использования, вы можете перейти на страницу Use SERP Data to Build Machine Learning Models.

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

Прежде чем мы углубимся в то, как оптимизировать процесс автоматического сбора данных для различных метаданных моделей машинного обучения. Я хотел бы дать читателю представление о том, как можно по-другому использовать генератор автоматической классификации изображений и SerpApi’s Google Images Scraper API.
Хотя форматы, отличные от изображений, не поддерживаются Генератором, бумажные формы или бумажные документы в формате изображений могут быть использованы для дальнейшего расширения текстовых данных. Вот пример запроса:

Детская площадка Ссылка на запрос

С помощью таких запросов, как «Изображения с цитатами Платона», вы можете расширить имеющийся у вас набор данных о цитатах известных людей, используя оптическое распознавание символов (OCR), интеллектуальное распознавание символов (ICR), и создать службу автоматизации процесса для автоматического бота, размещающего цитаты в социальных сетях.

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

Автоматизированный анализ данных модели

Поскольку процесс сбора данных осуществляется через API SerpApi’s Google Images Scraper, мы собираем данные для изображений, которые уже предварительно обработаны, используя запросы, как показано ниже:

Playground Ссылка на запрос

Улучшение качества данных напрямую влияет на простоту перекрестного сравнения неструктурированных алгоритмов и уменьшает необходимость вмешательства человека.
Хорошим примером может служить следующий пример. Мы создаем CNN (Convolutional Neural Network) с несколькими слоями Conv2d и Maxpool2d. Мы хотим рассчитать размер входа для первого полностью подключенного слоя. Чтобы сделать это для прямоугольного изображения, нам нужно вычислить пространственное разрешение для высоты и ширины в отдельных случаях. Это то, что можно будет расширить в Генераторе позже. Пока же мы будем использовать ранее собранные изображения 500×500 и применять к ним квадратные ядра для каждого сверточного и объединяющего слоя. Вот простая для понимания функция, в которую встроена формула:

def calculate_fully_connected(layers, size):
  for layer in layers:
    k = 1
    p = 0
    s = 1
    d = 1
    if "kernel_size" in layer:
      k = layer["kernel_size"]
    if "padding" in layer:
      p = layer["padding"]
    if "stride" in layer:
      s = layer["stride"]
    if "dilation" in layer:
      d = layer["dilation"]
    size = math.floor((size + 2*p - d*(k-1) - 1)/s + 1)

  return size

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

models = [
  [
    {
      "name": "Conv2d",
      "in_channels": 3,
      "out_channels": 6,
      "kernel_size": 5
    },
    {
      "name": "ReLU",
      "inplace": True
    },
    {
      "name": "MaxPool2d",
      "kernel_size": 2,
      "stride": 2
    },
    {
      "name": "Conv2d",
      "in_channels": 6,
      "out_channels": 16,
      "kernel_size": 5
    },
    {
      "name": "ReLU",
      "inplace": True
    },
    {
      "name": "MaxPool2d",
      "kernel_size": 2,
      "stride": 2
    },
    {
      "name": "Flatten",
      "start_dim": 1
    },
    {
      "name": "Linear",
      "in_features": "change_with_calculated_fn_size",
      "out_features": 120
    },
    {
      "name": "ReLU",
      "inplace": True
    },
    {
      "name": "Linear",
      "in_features": 120,
      "out_features": 84
    },
    {
      "name": "ReLU",
      "inplace": True
    },
    {
      "name": "Linear",
      "in_features": 84,
      "out_features": "n_labels"
    }
  ]
]

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

optimizers = [
  "AdamW"
]

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

Далее мы объявим диапазон и шаговый интервал для скорости обучения:

lr = 0.001
lr_range = []
while lr < 1.0:
  lr = lr + 0.001
  lr_range.append(lr)

loss_functions = [
  "PoissonNLLLoss"
]

Скорость обучения будет варьироваться от 0,001 до 1,0 с шагом 0,001.

Также нам нужно объявить список функций потерь. Мы объявим только одну:

loss_functions = [
  "PoissonNLLLoss"
]

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

i = 0

Мы могли бы взять эту следующую часть из модели. Но output_size обозначает размер вывода последнего слоя Conv2d в модели. Это будет полезно для вычисления размера полностью подключенного линейного входа.

output_size = 16

Мы уменьшим размер изображений 500×500 до 32×32, чтобы сэкономить вычислительную мощность. Опять же, мы могли бы взять его из объявления обучающего словаря. Он будет использоваться в качестве второго параметра функции calculate_fully_connected.

image_size = 32

Объявим пустой массив для хранения словаря команд автоматического обучения:

training_dicts = []

Начнем итерацию по различным спискам. Поскольку у нас только один элемент в каждом списке, кроме lr_range, эта итерация будет проверять наилучшую скорость обучения при определенном размере эпохи для оптимизатора AdamW, используя функцию потерь PoissonNLLLoss, и используя описанную модель CNN.

for model in models:
  for optimizer in optimizers:
    for lr in lr_range:
      for loss_function in loss_functions:

Давайте дадим каждой модели свое имя с помощью счетчика:

model_name = "american_dog_species_iterated_{}".format(str(i))

Следующий шаг — вычисление размера входа полностью подключенного слоя. Обратите внимание, что это не размер, который будет использоваться, а переменная для его нахождения. Мы будем использовать модель CNN, которую мы объявили в списке моделей, и размер изображения. Поскольку мы используем изображения 32×32, а ядра 5×5 и 2×2, мы можем смело вычислить одно число и использовать его для высоты и длины:

calculated_fc_size = calculate_fully_connected(model,image_size)

Затем нам нужно изменить размер входа полностью подключенного слоя на рассчитанное значение:

        for layer in model:
          if (layer["name"] == "Linear") and (layer["in_features"] == "change_with_calculated_fn_size"):
            model[model.index(layer)]['in_features'] = calculated_fc_size * calculated_fc_size * output_size ## Assuming image shape and kernel are squares
            break

Как вы можете видеть, конечным результатом будет вычисленное число в квадрате, умноженное на размер выхода.

Теперь нам нужно объявить словарь обучения с переменными, по которым мы будем проводить итерации:

        training_dict = {
          "model_name": model_name,
          "criterion": {
            "name": loss_function
          },
          "optimizer": {
            "name": optimizer,
            "lr": 0.001
          },
          "batch_size": 4,
          "n_epoch": 5,
          "n_labels": 0,
          "image_ops": [
            {
              "resize": {
                "size": [
                  image_size,
                  image_size
                ],
                "resample": "Image.ANTIALIAS"
              }
            },
            {
              "convert": {
                "mode": "'RGB'"
              }
            }
          ],
          "transform": {
            "ToTensor": True,
            "Normalize": {
              "mean": [
                0.5,
                0.5,
                0.5
              ],
              "std": [
                0.5,
                0.5,
                0.5
              ]
            }
          },
          "target_transform": {
            "ToTensor": True
          },
          "label_names": [
            "American Hairless Terrier imagesize:500x500",
            "Alaskan Malamute imagesize:500x500",
            "American Eskimo Dog imagesize:500x500",
            "Australian Shepherd imagesize:500x500",
            "Boston Terrier imagesize:500x500",
            "Boykin Spaniel imagesize:500x500",
            "Chesapeake Bay Retriever imagesize:500x500",
            "Catahoula Leopard Dog imagesize:500x500",
            "Toy Fox Terrier imagesize:500x500"
          ],
          "model": {
            "name": "",
            "layers": model
          }
        }

Давайте добавим учебные словари в training_dicts, чтобы собрать их в один список:

        training_dicts = training_dicts + [training_dict]

Наконец, мы увеличиваем счетчик:

i = i + 1

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

results = []
for training_dict in training_dicts:
  print("---")
  print("Training Model: {}".format(training_dict['model_name']))
  body = json.dumps(training_dict)
  response = requests.post("http://localhost:8000/train", headers = {"Content-Type": "application/json"}, data=body, allow_redirects = True)
  if response.status_code == 200:
    while True:
      response = requests.post("http://localhost:8000/find_attempt/?name={}".format(training_dict["model_name"]), headers = {"Content-Type": "application/json"}, allow_redirects = True)
      if response.json()['status'] == "Trained":
        break
      time.sleep(0.001)
  testing_dict = training_dict
  testing_dict['limit'] = 100
  body = json.dumps(testing_dict)
  response = requests.post("http://localhost:8000/test", headers = {"Content-Type": "application/json"}, data=body, allow_redirects = True)
  if response.status_code == 200:
    while True:
      response = requests.post("http://localhost:8000/find_attempt/?name={}".format(training_dict["model_name"]), headers = {"Content-Type": "application/json"}, allow_redirects = True)
      if response.json()['status'] == "Complete":
        break
      time.sleep(0.001)
  results = results + [response.json()]
  print("Accuracy: {}".format(response.json()['accuracy']))
  print("---")

Для каждого учебного словаря мы будем посылать запрос на конечную точку train, чтобы обучить модель, проверить, закончила ли она обучение по find_attempt, протестировать ее на 100 случайных изображениях с метками, предоставленными с конечной точки test, а затем снова проверить, закончилось ли тестирование. Наконец, мы будем хранить все данные обучения и тестирования каждого автоматизированного процесса в списке под названием results.

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

accuracy = 0.0
most_accurate_training = []
for result in results:
  if accuracy < result['accuracy']:
    most_accurate_training = result

print(most_accurate_training)

Полный код вы можете найти в gist ниже:

Полный код

Заключение

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