Quick Draw Doodle Recognition: как да свържем R, C++ и невронни мрежи

Здравейте, Хабр!

През есента на миналата година в Kaggle имаше конкурс за классификация на нарисувани картинки Quick Draw Doodle Recognition, в който участва екип от R програмисти, съставен от Артьом Клевцов, Филип Упративелев и Андрей Огурцов. Няма да описваме подробно състезанието, това вече е направено в скорошна публикация.

Този път не успяхме да спечелим медали, но получихме много ценен опит, затова искам да споделя с общността някои от най-интерестните и полезни неща, които разгледахме в Kaggle и в ежедневната работа. Сред разгледаните теми: трудният живот без OpenCV, парсинг на JSON (в тези примери се разглеждат интеграции на C++ код в скриптове или пакети на R чрез Rcpp), параметризиране на скриптове и контейнеризация на крайното решение. Целият код от публикацията в удобен за изпълнение вид е наличен в репозитории.

Съдържание:

1. Ефективно зареждане на данни от CSV в база MonetDB
2. Подготовка на партиди
3. Итератори за извличане на партиди от БД
4. Избор на архитектура на модела
5. Параметризиране на скриптове
6. Контейнеризация на скриптове
7. Използване на няколко GPU в облака Google Cloud
8. Вместо заключение

1. Ефективно зареждане на данни от CSV в база MonetDB

Данните в това състезание се предоставят не във формата на готови картинки, а в 340 CSV файла (по един файл на всеки клас), съдържащи JSON с координати на точки. Свързвайки тези точки с линии, получаваме крайно изображение с размер 256x256 пиксела. Също така за всяка записа посочва етикет, дали картинката е била коректно разпозната от използвания по време на събиране на данни класификатор, двубуквен код на страната на пребиваване на автора на рисунката, уникален идентификатор, времеви етикет и название на класа, което съвпада с името на файла. Оптимизираната версия на изходните данни е с обем 7.4 Гб в архив и приблизително 20 Гб след разархивиране, пълните данни след разархивиране заемат 240 Гб. Организаторите гарантираха, че и двете версии възпроизвеждат едни и същи рисунки, т.е. пълната версия е излишна. Във всеки случай, съхранението на 50 милиона картинки в графични файлове или под формата на масиви веднага беше признато за нерентабилно и решихме да слеем всички CSV файлове от архива train_simplified.zip в база данни с последваща генерация на картинки с нужния размер "на лето" за всяка партида.

За СУБД беше избрана добре утвърдената MonetDB, а именно реализацията за R под формата на пакет MonetDBLite. Пакетът включва в себе си вградената версия на сървъра на базата данни и позволява стартиране на сървъра директно от R сесия и работа с него там. Създаването на базата данни и свързването с нея се извършва с една команда:

con <- DBI::dbConnect(drv = MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))

Нужно да създадем две таблици: една за всички данни и друга за служебна информация за качените файлове (ще е полезна, ако нещо не тръгне и процесът трябва да бъде възобновен след качването на няколко файла):

Създаване на таблици

if (!DBI::dbExistsTable(con, "doodles")) {
  DBI::dbCreateTable(
    con = con,
    name = "doodles",
    fields = c(
      "countrycode" = "char(2)",
      "drawing" = "text",
      "key_id" = "bigint",
      "recognized" = "bool",
      "timestamp" = "timestamp",
      "word" = "text"
    )
  )
}

if (!DBI::dbExistsTable(con, "upload_log")) {
  DBI::dbCreateTable(
    con = con,
    name = "upload_log",
    fields = c(
      "id" = "serial",
      "file_name" = "text UNIQUE",
      "uploaded" = "bool DEFAULT false"
    )
  )
}

Най-бързият начин за качване на данни в БД се оказа директното копиране на CSV файлове с SQL — командата COPY OFFSET 2 INTO tablename FROM path USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORT, където tablename — името на таблицата и път — пътя към файла. При работа с архива бeше открито, че вградената реализация unzip в R неправилно работи с някои файлове от архива, затова използвахме системната unzip (чрез параметъра getOption("unzip")).

Функция за запис в базата

#' @title Извлечение и загрузка файлов
#'
#' @description
#' Извлечение CSV-файлов из ZIP-архива и загрузка их в базу данных
#'
#' @param con Объект подключения к базе данных (класс `MonetDBEmbeddedConnection`).
#' @param tablename Название таблицы в базе данных.
#' @oaram zipfile Путь к ZIP-архиву.
#' @oaram filename Имя файла внури ZIP-архива.
#' @param preprocess Функция предобработки, которая будет применена извлечённому файлу.
#'   Должна принимать один аргумент `data` (объект `data.table`).
#'
#' @return `TRUE`.
#'
upload_file <- function(con, tablename, zipfile, filename, preprocess = NULL) {
  # Проверка аргументов
  checkmate::assert_class(con, "MonetDBEmbeddedConnection")
  checkmate::assert_string(tablename)
  checkmate::assert_string(filename)
  checkmate::assert_true(DBI::dbExistsTable(con, tablename))
  checkmate::assert_file_exists(zipfile, access = "r", extension = "zip")
  checkmate::assert_function(preprocess, args = c("data"), null.ok = TRUE)

  # Извлечение файла
  path <- file.path(tempdir(), filename)
  unzip(zipfile, files = filename, exdir = tempdir(), 
        junkpaths = TRUE, unzip = getOption("unzip"))
  on.exit(unlink(file.path(path)))

  # Применяем функция предобработки
  if (!is.null(preprocess)) {
    .data <- data.table::fread(file = path)
    .data <- preprocess(data = .data)
    data.table::fwrite(x = .data, file = path, append = FALSE)
    rm(.data)
  }

  # Запрос к БД на импорт CSV
  sql <- sprintf(
    "COPY OFFSET 2 INTO %s FROM '%s' USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORT",
    tablename, path
  )
  # Выполнение запроса к БД
  DBI::dbExecute(con, sql)

  # Добавление записи об успешной загрузке в служебную таблицу
  DBI::dbExecute(con, sprintf("INSERT INTO upload_log(file_name, uploaded) VALUES('%s', true)",
                              filename))

  return(invisible(TRUE))
}

Ако е необходимо да преобразувате таблицата преди запис в БД, просто подадете в аргумента preprocess функция, която ще преобразува данните.

Код за последователно качване на данни в базата:

Записване на данни в базата

# Список файлов для записи
files <- unzip(zipfile, list = TRUE)$Name

# Список исключений, если часть файлов уже была загружена
to_skip <- DBI::dbGetQuery(con, "SELECT file_name FROM upload_log")[[1L]]
files <- setdiff(files, to_skip)

if (length(files) > 0L) {
  # Запускаем таймер
  tictoc::tic()
  # Прогресс бар
  pb <- txtProgressBar(min = 0L, max = length(files), style = 3)
  for (i in seq_along(files)) {
    upload_file(con = con, tablename = "doodles", 
                zipfile = zipfile, filename = files[i])
    setTxtProgressBar(pb, i)
  }
  close(pb)
  # Останавливаем таймер
  tictoc::toc()
}

# 526.141 sec elapsed - копирование SSD->SSD
# 558.879 sec elapsed - копирование USB->SSD

Времето за качване на данни може да варира в зависимост от скоростните характеристики на използвания носител. В нашия случай четенето и записът в рамките на един SSD или от флаш памет (изходният файл) на SSD (БД) отнема по-малко от 10 минути.

Още няколко секунди са необходими за създаването на столбец с целочислена етикета на класа и колона с индекс (ORDERED INDEX) с номера на редовете, по който ще се извършва извличането на наблюдения при създаването на партиди:

Създаване на допълнителни столбци и индекс

message("Генериране на етикети")
invisible(DBI::dbExecute(con, "ALTER TABLE doodles ADD label_int int"))
invisible(DBI::dbExecute(con, "UPDATE doodles SET label_int = dense_rank() OVER (ORDER BY word) - 1"))

message("Генериране на номер на редове")
invisible(DBI::dbExecute(con, "ALTER TABLE doodles ADD id serial"))
invisible(DBI::dbExecute(con, "CREATE ORDERED INDEX doodles_id_ord_idx ON doodles(id)"))

За да разрешим задачата по формирането на партидата "на лету", беше необходимо да постигнем максимална скорост на извличане на случайни редове от таблицата doodles. За тази цел използвахме 3 трика. Първият беше да намалим размерността на типа, в който се съхранява ID-то на наблюдението. В изходния набор от данни за съхранение на ID е необходим тип bigint, но количеството наблюдения позволява да вместим техните идентификатори, равни на редовия номер, в тип int. Търсенето в този случай става значително по-бързо. Вторият трик беше използването на ORDERED INDEX — до това решение стигнахме емпирично, опитвайки различните налични варианти. Третият се състоеше в използването на параметризирани заявки. Същността на метода се състои в еднократното изпълнение на командата PREPARE с последующим използване на подготвено изразяване при създаване на купчина еднотипни заявки, но в действителност подобрението е в рамките на статистическата грешка. SELECT Този подход позволява обработка на данни между 450 MB RAM. Това означава, че описаният метод дава възможност за работа с набори от данни с размери в десетки гигабайти на почти всякакво бюджетно оборудване, включително някои мини компютри, което е доста впечатляващо.

Остава да направим измервания на скоростта на извличане на (случайни) данни и да оценим мащабирането при извличане на партиди с различен размер:

Бенчмарк на базата данни

library(ggplot2)set.seed(0) # Свързване с базата данни con <- DBI::dbConnect(MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))# Функция за подготовка на заявка на страната на сървъра prep_sql <- function(batch_size) { sql <- sprintf("PREPARE SELECT id FROM doodles WHERE id IN (%s)", paste(rep("?", batch_size), collapse = ",")) res <- DBI::dbSendQuery(con, sql) return(res) }# Функция за извличане на данни fetch_data <- function(rs, batch_size) { ids <- sample(seq_len(n), batch_size) res <- DBI::dbFetch(DBI::dbBind(rs, as.list(ids))) return(res) }# Провеждане на измерване res_bench <- bench::press( batch_size = 2^(4:10), { rs <- prep_sql(batch_size) bench::mark( fetch_data(rs, batch_size), min_iterations = 50L ) } ) # Параметри на бенчмарка cols <- c("batch_size", "min", "median", "max", "itr/sec", "total_time", "n_itr") res_bench[, cols]# batch_size min median max `itr/sec` total_time n_itr # # 1 16 23.6ms 54.02ms 93.43ms 18.8 2.6s 49 # 2 32 38ms 84.83ms 151.55ms 11.4 4.29s 49 # 3 64 63.3ms 175.54ms 248.94ms 5.85 8.54s 50 # 4 128 83.2ms 341.52ms 496.24ms 3.00 16.69s 50 # 5 256 232.8ms 653.21ms 847.44ms 1.58 31.66s 50 # 6 512 784.6ms 1.41s 1.98s 0.740 1.1m 49 # 7 1024 681.7ms 2.72s 4.06s 0.377 2.16m 49ggplot(res_bench, aes(x = factor(batch_size), y = median, group = 1)) + geom_point() + geom_line() + ylab("медийно време, с") + theme_minimal()DBI::dbDisconnect(con, shutdown = TRUE)

2. Подготовка на партиди

Целият процес на подготовка на партиди включва следните етапи:

Парсване на няколко JSON обекта, съдържащи вектори от низове с координати на точки.

1. Рисуване на цветни линии по координатите на точките на изображение с необходим размер (например 256×256 или 128×128).
2. Превръщане на получените изображения в тензор.
3. В рамките на състезание сред kernel-ите на Python задачата предимно се решаваше с помощта на

. Един от най-простите и очевидни аналози на R ще изглежда по следния начин: OpenCVРеализация на преобразуването на JSON в тензор на R

Реализация на преобразуването на JSON в тензор в R

r_process_json_str <- function(json, line.width = 3, 
                               color = TRUE, scale = 1) {
  # Парсинг JSON
  coords <- jsonlite::fromJSON(json, simplifyMatrix = FALSE)
  tmp <- tempfile()
  # Удаляем временный файл по завершению функции
  on.exit(unlink(tmp))
  png(filename = tmp, width = 256 * scale, height = 256 * scale, pointsize = 1)
  # Пустой график
  plot.new()
  # Размер окна графика
  plot.window(xlim = c(256 * scale, 0), ylim = c(256 * scale, 0))
  # Цвета линий
  cols <- if (color) rainbow(length(coords)) else "#000000"
  for (i in seq_along(coords)) {
    lines(x = coords[[i]][[1]] * scale, y = coords[[i]][[2]] * scale, 
          col = cols[i], lwd = line.width)
  }
  dev.off()
  # Преобразование изображения в 3-х мерный массив
  res <- png::readPNG(tmp)
  return(res)
}

r_process_json_vector <- function(x, ...) {
  res <- lapply(x, r_process_json_str, ...)
  # Объединение 3-х мерных массивов картинок в 4-х мерный в тензор
  res <- do.call(abind::abind, c(res, along = 0))
  return(res)
}

Рисуването се извършва с помощта на стандартните средства на R, като се запазва във временно PNG, съхраняван в оперативната памет (в Linux временното директории на R се намират в директорията /tmp, монтирана в оперативната памет). След това този файл се прочита като тримерен масив с числа в диапазона от 0 до 1. Това е важно, тъй като по-разпространеният BMP би бил прочетен в raw-масив с hex-кодове на цветовете.

Нека тестваме резултата:

zip_file <- file.path("data", "train_simplified.zip")
csv_file <- "cat.csv"
unzip(zip_file, files = csv_file, exdir = tempdir(), 
      junkpaths = TRUE, unzip = getOption("unzip"))
tmp_data <- data.table::fread(file.path(tempdir(), csv_file), sep = ",", 
                              select = "drawing", nrows = 10000)
arr <- r_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256   3
plot(magick::image_read(arr))

Самият батч ще бъде формулиран по следния начин:

res <- r_process_json_vector(tmp_data[1:4, drawing], scale = 0.5)
str(res)
 # num [1:4, 1:128, 1:128, 1:3] 1 1 1 1 1 1 1 1 1 1 ...
 # - attr(*, "dimnames")=List of 4
 #  ..$ : NULL
 #  ..$ : NULL
 #  ..$ : NULL
 #  ..$ : NULL

Тази имплементация ни се стори неоптимална, тъй като формулирането на големи батчове отнема неприлично много време, и решихме да се възползваме от опита на колегите, използвайки мощна библиотека OpenCV. В този момент не съществуваше готов пакет за R (и в момента няма), затова бе написана минимална имплементация на необходимия функционал на C++ с интеграция в кода на R чрез Rcpp.

За решаване на задачата бяха използвани следните пакети и библиотеки:

1. OpenCV за работа с изображения и рисуване на линии. Използваха се предварително инсталирани системни библиотеки и заглавни файлове, както и динамична връзка.

2. xtensor за работа с многомерни масиви и тензори. Използваха се заглавни файлове, включени в едноименния R-пакет. Библиотеката позволява работа с многомерни масиви, както в row major, така и в column major ред.

3. ndjson за парсинг на JSON. Тази библиотека се използва в xtensor автоматично при наличието ѝ в проекта.

4. RcppThread за организиране на многопоточна обработка на вектори от JSON-ове. Използваха се заглавни файлове, предоставени от този пакет. В сравнение с по-популярната RcppParallel пакет, наред с другото, се отличава с вграден механизъм за прекъсване на цикли (interrupt).

Следва да се отбележи, че xtensor се оказа истинно находка: помимо обширного функционала и высокой производительности, разработчики оказались весьма отзывчивыми и быстро отвечали на возникающие вопросы. С их помощью удалось реализовать преобразования матриц OpenCV в тензоры xtensor, а также объединить 3D тензоры изображений в 4D тензор правильной размерности (собственно батч).

Материали за изучаване на Rcpp, xtensor и RcppThread

https://thecoatlessprofessor.com/programming/unofficial-rcpp-api-documentation

https://docs.opencv.org/4.0.1/d7/dbd/group__imgproc.html

https://xtensor.readthedocs.io/en/latest/

https://xtensor.readthedocs.io/en/latest/file_loading.html#loading-json-data-into-xtensor

https://cran.r-project.org/web/packages/RcppThread/vignettes/RcppThread-vignette.pdf

За компилиране на файловете, които използват системни файлове и динамична линковка с инсталираните в системата библиотеки, използвахме механизма на плъгините, реализиран в пакета Rcpp. За автоматично намиране на пътища и флагове използвахме популярната линукс утилита pkg-config.

Реализация на Rcpp плъгин за използване на библиотеката OpenCV

Rcpp::registerPlugin("opencv", function() {
  # Възможни имена на пакета
  pkg_config_name <- c("opencv", "opencv4")
  # Бинарен файл на утилитата pkg-config
  pkg_config_bin <- Sys.which("pkg-config")
  # Проверка за наличието на утилитата в системата
  checkmate::assert_file_exists(pkg_config_bin, access = "x")
  # Проверка за наличието на файл с настройки OpenCV за pkg-config
  check <- sapply(pkg_config_name, 
                  function(pkg) system(paste(pkg_config_bin, pkg)))
  if (all(check != 0)) {
    stop("OpenCV конфигурация за pkg-config не е намерена", call. = FALSE)
  }

  pkg_config_name <- pkg_config_name[check == 0]
  list(env = list(
    PKG_CXXFLAGS = system(paste(pkg_config_bin, "--cflags", pkg_config_name), 
                          intern = TRUE),
    PKG_LIBS = system(paste(pkg_config_bin, "--libs", pkg_config_name), 
                      intern = TRUE)
  ))
})

В резултат на работата на плъгина в процеса на компилиране ще бъдат подставени следните стойности:

Rcpp:::.plugins$opencv()$env

# $PKG_CXXFLAGS
# [1] "-I/usr/include/opencv"
#
# $PKG_LIBS
# [1] "-lopencv_shape -lopencv_stitching -lopencv_superres -lopencv_videostab -lopencv_aruco -lopencv_bgsegm -lopencv_bioinspired -lopencv_ccalib -lopencv_datasets -lopencv_dpm -lopencv_face -lopencv_freetype -lopencv_fuzzy -lopencv_hdf -lopencv_line_descriptor -lopencv_optflow -lopencv_video -lopencv_plot -lopencv_reg -lopencv_saliency -lopencv_stereo -lopencv_structured_light -lopencv_phase_unwrapping -lopencv_rgbd -lopencv_viz -lopencv_surface_matching -lopencv_text -lopencv_ximgproc -lopencv_calib3d -lopencv_features2d -lopencv_flann -lopencv_xobjdetect -lopencv_objdetect -lopencv_ml -lopencv_xphoto -lopencv_highgui -lopencv_videoio -lopencv_imgcodecs -lopencv_photo -lopencv_imgproc -lopencv_core"

Кодът за реализация на парсинга на JSON и създаването на батч за предаване в модела е показан в спойлер. Предварително добавяме локалната директория на проекта за търсене на заглавни файлове (нужно за ndjson):

Sys.setenv("PKG_CXXFLAGS" = paste0("-I", normalizePath(file.path("src"))))

Реализация на преобразуването на JSON в тензор на C++

// [[Rcpp::plugins(cpp14)]]
// [[Rcpp::plugins(opencv)]]
// [[Rcpp::depends(xtensor)]]
// [[Rcpp::depends(RcppThread)]]

#include <xtensor/xjson.hpp>
#include <xtensor/xadapt.hpp>
#include <xtensor/xview.hpp>
#include <xtensor-r/rtensor.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <Rcpp.h>
#include <RcppThread.h>

// Синонимы для типов
using RcppThread::parallelFor;
using json = nlohmann::json;
using points = xt::xtensor<double,2>;     // Извлечённые из JSON координаты точек
using strokes = std::vector<points>;      // Извлечённые из JSON координаты точек
using xtensor3d = xt::xtensor<double, 3>; // Тензор для хранения матрицы изоображения
using xtensor4d = xt::xtensor<double, 4>; // Тензор для хранения множества изображений
using rtensor3d = xt::rtensor<double, 3>; // Обёртка для экспорта в R
using rtensor4d = xt::rtensor<double, 4>; // Обёртка для экспорта в R

// Статические константы
// Размер изображения в пикселях
const static int SIZE = 256;
// Тип линии
// См. https://en.wikipedia.org/wiki/Pixel_connectivity#2-dimensional
const static int LINE_TYPE = cv::LINE_4;
// Толщина линии в пикселях
const static int LINE_WIDTH = 3;
// Алгоритм ресайза
// https://docs.opencv.org/3.1.0/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121
const static int RESIZE_TYPE = cv::INTER_LINEAR;

// Шаблон для конвертирования OpenCV-матрицы в тензор
template <typename T, int NCH, typename XT=xt::xtensor<T,3,xt::layout_type::column_major>>
XT to_xt(const cv::Mat_<cv::Vec<T, NCH>>& src) {
  // Размерность целевого тензора
  std::vector<int> shape = {src.rows, src.cols, NCH};
  // Общее количество элементов в массиве
  size_t size = src.total() * NCH;
  // Преобразование cv::Mat в xt::xtensor
  XT res = xt::adapt((T*) src.data, size, xt::no_ownership(), shape);
  return res;
}

// Преобразование JSON в список координат точек
strokes parse_json(const std::string& x) {
  auto j = json::parse(x);
  // Результат парсинга должен быть массивом
  if (!j.is_array()) {
    throw std::runtime_error("'x' must be JSON array.");
  }
  strokes res;
  res.reserve(j.size());
  for (const auto& a: j) {
    // Каждый элемент массива должен быть 2-мерным массивом
    if (!a.is_array() || a.size() != 2) {
      throw std::runtime_error("'x' must include only 2d arrays.");
    }
    // Извлечение вектора точек
    auto p = a.get<points>();
    res.push_back(p);
  }
  return res;
}

// Отрисовка линий
// Цвета HSV
cv::Mat ocv_draw_lines(const strokes& x, bool color = true) {
  // Исходный тип матрицы
  auto stype = color ? CV_8UC3 : CV_8UC1;
  // Итоговый тип матрицы
  auto dtype = color ? CV_32FC3 : CV_32FC1;
  auto bg = color ? cv::Scalar(0, 0, 255) : cv::Scalar(255);
  auto col = color ? cv::Scalar(0, 255, 220) : cv::Scalar(0);
  cv::Mat img = cv::Mat(SIZE, SIZE, stype, bg);
  // Количество линий
  size_t n = x.size();
  for (const auto& s: x) {
    // Количество точек в линии
    size_t n_points = s.shape()[1];
    for (size_t i = 0; i < n_points - 1; ++i) {
      // Точка начала штриха
      cv::Point from(s(0, i), s(1, i));
      // Точка окончания штриха
      cv::Point to(s(0, i + 1), s(1, i + 1));
      // Отрисовка линии
      cv::line(img, from, to, col, LINE_WIDTH, LINE_TYPE);
    }
    if (color) {
      // Меняем цвет линии
      col[0] += 180 / n;
    }
  }
  if (color) {
    // Меняем цветовое представление на RGB
    cv::cvtColor(img, img, cv::COLOR_HSV2RGB);
  }
  // Меняем формат представления на float32 с диапазоном [0, 1]
  img.convertTo(img, dtype, 1 / 255.0);
  return img;
}

// Обработка JSON и получение тензора с данными изображения
xtensor3d process(const std::string& x, double scale = 1.0, bool color = true) {
  auto p = parse_json(x);
  auto img = ocv_draw_lines(p, color);
  if (scale != 1) {
    cv::Mat out;
    cv::resize(img, out, cv::Size(), scale, scale, RESIZE_TYPE);
    cv::swap(img, out);
    out.release();
  }
  xtensor3d arr = color ? to_xt<double,3>(img) : to_xt<double,1>(img);
  return arr;
}

// [[Rcpp::export]]
rtensor3d cpp_process_json_str(const std::string& x, 
                               double scale = 1.0, 
                               bool color = true) {
  xtensor3d res = process(x, scale, color);
  return res;
}

// [[Rcpp::export]]
rtensor4d cpp_process_json_vector(const std::vector<std::string>& x, 
                                  double scale = 1.0, 
                                  bool color = false) {
  size_t n = x.size();
  size_t dim = floor(SIZE * scale);
  size_t channels = color ? 3 : 1;
  xtensor4d res({n, dim, dim, channels});
  parallelFor(0, n, [&x, &res, scale, color](int i) {
    xtensor3d tmp = process(x[i], scale, color);
    auto view = xt::view(res, i, xt::all(), xt::all(), xt::all());
    view = tmp;
  });
  return res;
}

Този код трябва да бъде поставен в файла src/cv_xt.cpp и да бъде компилиран с командата Rcpp::sourceCpp(file = "src/cv_xt.cpp", env = .GlobalEnv); за работата ще е необходимо и nlohmann/json.hpp от репозитория. Кодът е разделен на няколко функции:

• to_xt — шаблонизирана функция за преобразуване на матрица на изображение (cv::Mat) в тензор xt::xtensor;

• parse_json — функцията парсва JSON низ, извлича координатите на точките, опакова ги във вектор;

• ocv_draw_lines — от получения вектор точки рисува разноцветни линии;

• process — съчетава гореспоменатите функции и добавя възможността за мащабиране на получения образ;

• cpp_process_json_str — обвивка над функцията process, която експортира резултата в R обект (многоизмерен масив);

• cpp_process_json_vector — обвивка над функцията cpp_process_json_str, която позволява обработка на низов вектор в многонишков режим.

За рисуването на многоцветни линии беше използвана цветова модель HSV с последваща конверсия в RGB. Нека тестваме резултата:

arr <- cpp_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256   3
plot(magick::image_read(arr))

Сравнение на скоростта на работа на реализациите на R и C++

res_bench <- bench::mark(
  r_process_json_str(tmp_data[4, drawing], scale = 0.5),
  cpp_process_json_str(tmp_data[4, drawing], scale = 0.5),
  check = FALSE,
  min_iterations = 100
)
# Параметри на бенчмарк теста
cols <- c("expression", "min", "median", "max", "itr/sec", "total_time", "n_itr")
res_bench[, cols]

#   expression                min     median       max `itr/sec` total_time  n_itr
#                                  
# 1 r_process_json_str     3.49ms     3.55ms    4.47ms      273.      490ms    134
# 2 cpp_process_json_str   1.94ms     2.02ms    5.32ms      489.      497ms    243

library(ggplot2)
# Провеждане на замера
res_bench <- bench::press(
  batch_size = 2^(4:10),
  {
    .data <- tmp_data[sample(seq_len(.N), batch_size), drawing]
    bench::mark(
      r_process_json_vector(.data, scale = 0.5),
      cpp_process_json_vector(.data,  scale = 0.5),
      min_iterations = 50,
      check = FALSE
    )
  }
)

res_bench[, cols]

#    expression   batch_size      min   median      max `itr/sec` total_time n_itr
#                  & & &         &
#  1 r                   16   50.61ms  53.34ms  54.82ms    19.1     471.13ms     9
#  2 cpp                 16    4.46ms   5.39ms   7.78ms   192.      474.09ms    91
#  3 r                   32   105.7ms 109.74ms 212.26ms     7.69        6.5s    50
#  4 cpp                 32    7.76ms  10.97ms  15.23ms    95.6     522.78ms    50
#  5 r                   64  211.41ms 226.18ms 332.65ms     3.85      12.99s    50
#  6 cpp                 64   25.09ms  27.34ms  32.04ms    36.0        1.39s    50
#  7 r                  128   534.5ms 627.92ms 659.08ms     1.61      31.03s    50
#  8 cpp                128   56.37ms  58.46ms  66.03ms    16.9        2.95s    50
#  9 r                  256     1.15s    1.18s    1.29s     0.851     58.78s    50
# 10 cpp                256  114.97ms 117.39ms 130.09ms     8.45       5.92s    50
# 11 r                  512     2.09s    2.15s    2.32s     0.463       1.8m    50
# 12 cpp                512  230.81ms  235.6ms 261.99ms     4.18      11.97s    50
# 13 r                 1024        4s    4.22s     4.4s     0.238       3.5m    50
# 14 cpp               1024  410.48ms 431.43ms 462.44ms     2.33      21.45s    50

ggplot(res_bench, aes(x = factor(batch_size), y = median, 
                      group =  expression, color = expression)) +
  geom_point() +
  geom_line() +
  ylab("медийно време, с") +
  theme_minimal() +
  scale_color_discrete(name = "", labels = c("cpp", "r")) +
  theme(legend.position = "bottom") 

Както виждаме, увеличението на скоростта се оказа много значително, и постигането на код на C++ чрез паралелизиране на кода на R не представлява възможност.

3. Итератори за извличане на батчове от БД

R има заслужена репутация на език за обработка на данни, които влизат в ОЗУ, докато за Python е по-характерна итеративната обработка на данни, която позволява лесно и безпроблемно реализиране на out-of-core изчисления (изчисления с използване на външна памет). Класическият и актуален за нас в контекста на описаната задача пример за такива изчисления са дълбоките невронни мрежи, обучавани с метода на градиентното спускане с аппроксимация на градиента на всяка стъпка с малък набор от наблюдения, или мини-батч.

Фреймворките за дълбоко обучение, написани на Python, имат специални класове, реализиращи итератори за данни: таблици, изображения в папки, бинарни формати и т.н. Могат да се използват готови варианти или да се пишат собствени за специфични задачи. В R можем да се възползваме от всички възможности на Python библиотеката keras с нейните различни бекенди чрез съответния пакет, който от своя страна работи над пакета reticulate. Последният заслужава отделна голяма статия; той не само позволява изпълнението на код на Python от R, но също така осигурява преноса на обекти между R и Python сесии, автоматично извършвайки всички необходими преобразувания на типове.

От необходимостта да съхраняваме всички данни в ОЗУ се избавихме благодарение на използването на MonetDBLite, цялата "нейросетова" работа ще бъде извършена от оригиналния код на Python, а ние само трябва да напишем итератор за данни, тъй като готов за такава ситуация няма нито на R, нито на Python. По същество изискванията към него са само две: той трябва да връща батчове в безкраен цикъл и да запазва състоянието си между итерациите (последното в R се реализира най-лесно с помощта на замикания). По-рано беше необходимо вътре в итератора явно да преобразуваме масиви от R в numpy масиви, но актуалната версия на пакета keras прави това сама.

Итераторът за обучаващи и валидиращи данни изглежда следния:

Итератор за обучаващи и валидиращи данни

train_generator <- function(db_connection = con,
                            samples_index,
                            num_classes = 340,
                            batch_size = 32,
                            scale = 1,
                            color = FALSE,
                            imagenet_preproc = FALSE) {
  # Проверка аргументов
  checkmate::assert_class(con, "DBIConnection")
  checkmate::assert_integerish(samples_index)
  checkmate::assert_count(num_classes)
  checkmate::assert_count(batch_size)
  checkmate::assert_number(scale, lower = 0.001, upper = 5)
  checkmate::assert_flag(color)
  checkmate::assert_flag(imagenet_preproc)

  # Перемешиваем, чтобы брать и удалять использованные индексы батчей по порядку
  dt <- data.table::data.table(id = sample(samples_index))
  # Проставляем номера батчей
  dt[, batch := (.I - 1L) %/% batch_size + 1L]
  # Оставляем только полные батчи и индексируем
  dt <- dt[, if (.N == batch_size) .SD, keyby = batch]
  # Устанавливаем счётчик
  i <- 1
  # Количество батчей
  max_i <- dt[, max(batch)]

  # Подготовка выражения для выгрузки
  sql <- sprintf(
    "PREPARE SELECT drawing, label_int FROM doodles WHERE id IN (%s)",
    paste(rep("?", batch_size), collapse = ",")
  )
  res <- DBI::dbSendQuery(con, sql)

  # Аналог keras::to_categorical
  to_categorical <- function(x, num) {
    n <- length(x)
    m <- numeric(n * num)
    m[x * n + seq_len(n)] <- 1
    dim(m) <- c(n, num)
    return(m)
  }

  # Замыкание
  function() {
    # Начинаем новую эпоху
    if (i > max_i) {
      dt[, id := sample(id)]
      data.table::setkey(dt, batch)
      # Сбрасываем счётчик
      i <<- 1
      max_i <<- dt[, max(batch)]
    }

    # ID для выгрузки данных
    batch_ind <- dt[batch == i, id]
    # Выгрузка данных
    batch <- DBI::dbFetch(DBI::dbBind(res, as.list(batch_ind)), n = -1)

    # Увеличиваем счётчик
    i <<- i + 1

    # Парсинг JSON и подготовка массива
    batch_x <- cpp_process_json_vector(batch$drawing, scale = scale, color = color)
    if (imagenet_preproc) {
      # Шкалирование c интервала [0, 1] на интервал [-1, 1]
      batch_x <- (batch_x - 0.5) * 2
    }

    batch_y <- to_categorical(batch$label_int, num_classes)
    result <- list(batch_x, batch_y)
    return(result)
  }
}

Функцията приема като вход променлива за свързване с БД, номера на използваните редове, брой класове, размер на батча, мащаб (scale = 1 съответства на изображението с размери 256x256 пиксела, scale = 0.5 — 128x128 пиксела), индикатор за цветността (color = FALSE определя изображение в нюанси на сивото, при използването на color = TRUE всеки штрих се рисува с нов цвят) и индикатор за предпроцесинг за мрежи, предварително обучени на imagenet. Последният е необходим, за да отшкалируеме стойностите на пикселите от интервала [0, 1] на интервала [-1, 1], който е използван при обучението на предоставените в комплекта keras модели.

Външната функция съдържа проверка на типовете аргументи, таблица data.table с произволно разбъркани номера на редове от samples_index и номери на партиди, брояча и максималния брой партиди, както и SQL израз за извличане на данни от БД. Допълнително определихме бърз аналог на функцията keras::to_categorical(). Използвахме почти всички данни за обучение, оставяйки половин процент за валидиране, затова размерът на епохата бе ограничен от параметъра steps_per_epoch при повикването на keras::fit_generator(), и условието if (i > max_i) сработваше само за валидиращия итератор.

Във вътрешната функция се извършва избор на индекси на редове за текущата партида, извличане на записи от БД с увеличаване на брояча на партидите, парсване на JSON (функция cpp_process_json_vector(), написана на C++) и създаване на масиви, отговарящи на изображенията. След това се създават one-hot вектори с класовите етикети, масиви със стойности на пикселите и етикетите се обединяват в списък, който е възвращаемото значение. За ускоряване на работата бе използвано създаването на индекси в таблиците data.table и модификация по референция — без тези „трикове“ на пакета data.table е доста трудно да си представим ефективна работа с каквито и да било значителни обеми данни в R.

Резултатите от измерванията на скоростта на работа на лаптоп с Core i5 изглеждат по следния начин:

Бенчмарк на итератора

library(Rcpp)
library(keras)
library(ggplot2)

source("utils/rcpp.R")
source("utils/keras_iterator.R")

con <- DBI::dbConnect(drv = MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))

ind <- seq_len(DBI::dbGetQuery(con, "SELECT count(*) FROM doodles")[[1L]])
num_classes <- DBI::dbGetQuery(con, "SELECT max(label_int) + 1 FROM doodles")[[1L]]

# Индекси за обучаваща извадка
train_ind <- sample(ind, floor(length(ind) * 0.995))
# Индекси за проверочна извадка
val_ind <- ind[-train_ind]
rm(ind)
# Коэффициент на скалата
scale <- 0.5

# Провеждане на измерването
res_bench <- bench::press(
  batch_size = 2^(4:10),
  {
    it1 <- train_generator(
      db_connection = con,
      samples_index = train_ind,
      num_classes = num_classes,
      batch_size = batch_size,
      scale = scale
    )
    bench::mark(
      it1(),
      min_iterations = 50L
    )
  }
)
# Параметри на бенчмарк
cols <- c("batch_size", "min", "median", "max", "itr/sec", "total_time", "n_itr")
res_bench[, cols]

#   batch_size      min   median      max `itr/sec` total_time n_itr
#                    
# 1         16     25ms  64.36ms   92.2ms     15.9       3.09s    49
# 2         32   48.4ms 118.13ms 197.24ms     8.17       5.88s    48
# 3         64   69.3ms 117.93ms 181.14ms     8.57       5.83s    50
# 4        128  157.2ms 240.74ms 503.87ms     3.85      12.71s    49
# 5        256  359.3ms 613.52ms 988.73ms     1.54       30.5s    47
# 6        512  884.7ms    1.53s    2.07s     0.674      1.11m    45
# 7       1024     2.7s    3.83s    5.47s     0.261      2.81m    44

ggplot(res_bench, aes(x = factor(batch_size), y = median, group = 1)) +
    geom_point() +
    geom_line() +
    ylab("медийно време, с") +
    theme_minimal()

DBI::dbDisconnect(con, shutdown = TRUE)

Ако има достатъчно обем на RAM, може да се ускори значително работата на базата данни, като се премести в самата RAM (за нашата задача 32 ГБ са достатъчни). По подразбиране в Linux се монтира дял /dev/shm, заемащ до половината от обема на RAM. Може да се определят и повече, като се редактира /etc/fstab, за да получим запис от вида tmpfs /dev/shm tmpfs defaults,size=25g 0 0. Обязательно перезагружаемся и проверяем результат, выполнив команду df -h.

Итераторът за тестови данни изглежда много по-просто, тъй като целият тестови набор от данни се побира в ОЗУ:

Итератор за тестови данни

test_generator <- function(dt,
                           batch_size = 32,
                           scale = 1,
                           color = FALSE,
                           imagenet_preproc = FALSE) {

  # Проверка аргументов
  checkmate::assert_data_table(dt)
  checkmate::assert_count(batch_size)
  checkmate::assert_number(scale, lower = 0.001, upper = 5)
  checkmate::assert_flag(color)
  checkmate::assert_flag(imagenet_preproc)

  # Проставляем номера батчей
  dt[, batch := (.I - 1L) %/% batch_size + 1L]
  data.table::setkey(dt, batch)
  i <- 1
  max_i <- dt[, max(batch)]

  # Замыкание
  function() {
    batch_x <- cpp_process_json_vector(dt[batch == i, drawing], 
                                       scale = scale, color = color)
    if (imagenet_preproc) {
      # Шкалирование c интервала [0, 1] на интервал [-1, 1]
      batch_x <- (batch_x - 0.5) * 2
    }
    result <- list(batch_x)
    i <<- i + 1
    return(result)
  }
}

4. Избор на архитектура на модела

Първата от използваните архитектури беше mobilenet v1, чиито характеристики са разгледани в това съобщението. Тя е налична в стандартната доставка keras и съответно е достъпна в съответния пакет за R. Но при опити да я използваме с едноканални изображения, се оказа нещо странно: входният тензор винаги трябва да има размерност (batch, height, width, 3), тоест числото на каналите не може да бъде променяно. В Python такова ограничение няма, затова се побързахме и написахме своя реализация на тази архитектура, следвайки оригиналната статия (без дропаута, който присъства в версията на keras):

Архитектурата mobilenet v1

library(keras)

top_3_categorical_accuracy <- custom_metric(
    name = "top_3_categorical_accuracy",
    metric_fn = function(y_true, y_pred) {
         metric_top_k_categorical_accuracy(y_true, y_pred, k = 3)
    }
)

layer_sep_conv_bn %
  layer_batch_normalization() %>% 
  layer_activation_relu() %>%
  layer_conv_2d(
    filters = filters * alpha,
    kernel_size = c(1, 1), 
    strides = c(1, 1)
  ) %>%
  layer_batch_normalization() %>% 
  layer_activation_relu() 
}

get_mobilenet_v1 <- function(input_shape = c(224, 224, 1),
                             num_classes = 340,
                             alpha = 1,
                             depth_multiplier = 1,
                             optimizer = optimizer_adam(lr = 0.002),
                             loss = "categorical_crossentropy",
                             metrics = c("categorical_crossentropy",
                                         top_3_categorical_accuracy)) {

  inputs <- layer_input(shape = input_shape)

  outputs %
    layer_conv_2d(filters = 32, kernel_size = c(3, 3), strides = c(2, 2), padding = "same") %>%
    layer_batch_normalization() %>% 
    layer_activation_relu() %>%
    layer_sep_conv_bn(filters = 64, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 128, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 128, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 256, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 256, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 1024, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 1024, strides = c(1, 1)) %>%
    layer_global_average_pooling_2d() %>%
    layer_dense(units = num_classes) %>%
    layer_activation_softmax()

    model % compile(
      optimizer = optimizer,
      loss = loss,
      metrics = metrics
    )

    return(model)
}

Недостатъците на подхода са очевидни. Иска се да се проверят много модели, но не е желателно да се преписва всяка архитектура на ръка. Също така, бяхме лишени от възможността да използваме теглата на модели, предварително обучени на imagenet. Както обикновено, решението дойде от изучаването на документацията. Функцията get_config() позволява да получите описание на модела в редактиране с подходящ формат (base_model_conf$layers — обикновен R-ски списък), а функцията from_config() извършва обратната трансформация в модел обект:

base_model_conf <- get_config(base_model)
base_model_conf$layers[[1]]$config$batch_input_shape[[4]] <- 1L
base_model <- from_config(base_model_conf)

Сега не е трудно да напишете универсална функция за получаване на който и да е от предоставените в комплект keras модели с обучени на imagenet тежести или без тях:

Функция за зареждане на готови архитектури

get_model <- function(name = "mobilenet_v2",
                      input_shape = NULL,
                      weights = "imagenet",
                      pooling = "avg",
                      num_classes = NULL,
                      optimizer = keras::optimizer_adam(lr = 0.002),
                      loss = "categorical_crossentropy",
                      metrics = NULL,
                      color = TRUE,
                      compile = FALSE) {
  # Проверка на аргументите
  checkmate::assert_string(name)
  checkmate::assert_integerish(input_shape, lower = 1, upper = 256, len = 3)
  checkmate::assert_count(num_classes)
  checkmate::assert_flag(color)
  checkmate::assert_flag(compile)

  # Получаваме обект от пакета keras
  model_fun <- get0(paste0("application_", name), envir = asNamespace("keras"))
  # Проверка наличието на обект в пакета
  if (is.null(model_fun)) {
    stop("Модел ", shQuote(name), " не е намерен.", call. = FALSE)
  }

  base_model <- model_fun(
    input_shape = input_shape,
    include_top = FALSE,
    weights = weights,
    pooling = pooling
  )

  # Ако изображението не е цветно, променяме размерността на входа
  if (!color) {
    base_model_conf <- keras::get_config(base_model)
    base_model_conf$layers[[1]]$config$batch_input_shape[[4]] <- 1L
    base_model <- keras::from_config(base_model_conf)
  }

  predictions <- keras::get_layer(base_model, "global_average_pooling2d_1")$output
  predictions <- keras::layer_dense(predictions, units = num_classes, activation = "softmax")
  model <- keras::keras_model(
    inputs = base_model$input,
    outputs = predictions
  )

  if (compile) {
    keras::compile(
      object = model,
      optimizer = optimizer,
      loss = loss,
      metrics = metrics
    )
  }

  return(model)
}

При използване на едноканални изображения предварително обучените тежести не се използват. Това би могло да бъде поправено: с помощта на функцията get_weights() за да получите тежестите на модела като списък от R-ски масиви, да промените размерността на първия елемент от този списък (взимайки някой един цветен канал или средно взети три), а след това да заредите тежестите обратно в модела с функцията set_weights(). Ние този функционал не добавихме, тъй като на този етап вече беше ясно, че е по-продуктивно да работим с цветни изображения.

Основната част от експериментите проведохме с използване на mobilenet версии 1 и 2, както и resnet34. В това състезание добре се представиха по-модерни архитектури, като SE-ResNeXt. За съжаление, в нашето разположение нямаше готови реализации, а собствени не написахме (но задължително ще напишем).

5. Параметризация на скриптовете

За удобство целият код за стартиране на обучението е организиран под формата на единен скрипт, параметризиран с помощта на docopt по следния начин:

док <- '
Употреба:
  train_nn.R --help
  train_nn.R --list-models
  train_nn.R [опции]

Опции:
  -h --help                   Показати це повідомлення.
  -l --list-models            Перелік доступних моделей.
  -m --model=<модель>          Ім'я нейронної мережі [за замовчуванням: mobilenet_v2].
  -b --batch-size=<розмір>      Розмір пакету [за замовчуванням: 32].
  -s --scale-factor=<співвідношення>   Фактор масштабування [за замовчуванням: 0.5].
  -c --color                  Використовувати кольорові лінії [за замовчуванням: FALSE].
  -d --db-dir=<шлях>          Шлях до каталогу бази даних [за замовчуванням: Sys.getenv("db_dir")].
  -r --validate-ratio=<співвідношення> Валідаційне співвідношення вибірки [за замовчуванням: 0.995].
  -n --n-gpu=<число>         Кількість графічних процесорів [за замовчуванням: 1].
'
args <- docopt::docopt(doc)

Пакет docopt є реалізацією http://docopt.org/ для R. Завдяки йому скрипти запускаються простими командами на кшталт Rscript bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db или ./bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db, якщо файл train_nn.R є виконуваним (ця команда запустить навчання моделі resnet50 на кольорових зображеннях розміром 128х128 пікселів, база даних повинна бути в папці /home/andrey/doodle_db). До списку можна додати швидкість навчання, тип оптимізатора та будь-які інші налаштовувані параметри. Під час підготовки публікації виявилося, що архітектура mobilenet_v2 в актуальній версії keras в R використовувати не може через не враховані в R-пакеті зміни — чекаємо, поки їх виправлять.

Цей підхід дозволив значно прискорити експерименти з різними моделями в порівнянні з більш традиційним запуском скриптів в RStudio (як можливу альтернативу відзначимо пакет tfruns). Але основна перевага полягає в можливості легко керувати запуском скриптів у докері або просто на сервері, не встановлюючи для цього RStudio.

6. Докеризація скриптів

Ми використовували докер для забезпечення портативності середовища для навчання моделей між членами команди та для оперативного розгортання в хмарі. Познайомитися з цим відносно незвичним для R-програміста інструментом можна з этой серії публікацій або з відеокурсу.

Докер дозволяє як створювати власні образи «з нуля», так і використовувати інші образи як основу для створення власних. При аналізі наявних варіантів ми дійшли висновку, що установлення драйверів NVIDIA, CUDA+cuDNN і бібліотек Python — досить об'ємна частина образу, і вирішили взяти за основу офіційний образ tensorflow/tensorflow:1.12.0-gpu, додавши туди необхідні R-пакети.

Фінальний докер-файл вийшов таким:

Dockerfile

ИЗ tensorflow/tensorflow:1.12.0-gpu

ДЕРЖАТЕЛЬ Artem Klevtsov 

Оболочка ["/bin/bash", "-c"]

ARG LOCALE="en_US.UTF-8"
ARG APT_PKG="libopencv-dev r-base r-base-dev littler"
ARG R_BIN_PKG="futile.logger checkmate data.table rcpp rapidjsonr dbi keras jsonlite curl digest remotes"
ARG R_SRC_PKG="xtensor RcppThread docopt MonetDBLite"
ARG PY_PIP_PKG="keras"
ARG DIRS="/db /app /app/data /app/models /app/logs"

RUN source /etc/os-release && 
    echo "deb https://cloud.r-project.org/bin/linux/ubuntu ${UBUNTU_CODENAME}-cran35/" > /etc/apt/sources.list.d/cran35.list && 
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9 && 
    add-apt-repository -y ppa:marutter/c2d4u3.5 && 
    add-apt-repository -y ppa:timsc/opencv-3.4 && 
    apt-get update && 
    apt-get install -y locales && 
    locale-gen ${LOCALE} && 
    apt-get install -y --no-install-recommends ${APT_PKG} && 
    ln -s /usr/lib/R/site-library/littler/examples/install.r /usr/local/bin/install.r && 
    ln -s /usr/lib/R/site-library/littler/examples/install2.r /usr/local/bin/install2.r && 
    ln -s /usr/lib/R/site-library/littler/examples/installGithub.r /usr/local/bin/installGithub.r && 
    echo 'options(Ncpus = parallel::detectCores())' >> /etc/R/Rprofile.site && 
    echo 'options(repos = c(CRAN = "https://cloud.r-project.org"))' >> /etc/R/Rprofile.site && 
    apt-get install -y $(printf "r-cran-%s " ${R_BIN_PKG}) && 
    install.r ${R_SRC_PKG} && 
    pip install ${PY_PIP_PKG} && 
    mkdir -p ${DIRS} && 
    chmod 777 ${DIRS} && 
    rm -rf /tmp/downloaded_packages/ /tmp/*.rds && 
    rm -rf /var/lib/apt/lists/*

COPY utils /app/utils
COPY src /app/src
COPY tests /app/tests
COPY bin/*.R /app/

ENV DBDIR="/db"
ENV CUDA_HOME="/usr/local/cuda"
ENV PATH="/app:${PATH}"

WORKDIR /app

VOLUME /db
VOLUME /app

CMD bash

За удобство используемые пакеты были вынесены в переменные; основная часть написанных скриптов копируется внутрь контейнеров при сборке. Также мы изменили командную оболочку на /bin/bash для удобства использования содержимого /etc/os-release. Это позволило избежать необходимости указывать версию ОС в коде.

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

Скрипт для запуска контейнера

#!/bin/sh

DBDIR=${PWD}/db
LOGSDIR=${PWD}/logs
MODELDIR=${PWD}/models
DATADIR=${PWD}/data
ARGS="--runtime=nvidia --rm -v ${DBDIR}:/db -v ${LOGSDIR}:/app/logs -v ${MODELDIR}:/app/models -v ${DATADIR}:/app/data"

if [ -z "$1" ]; then
    CMD="Rscript /app/train_nn.R"
elif [ "$1" = "bash" ]; then
    ARGS="${ARGS} -ti"
else
    CMD="Rscript /app/train_nn.R $@"
fi

docker run ${ARGS} doodles-tf ${CMD}

Если этот баш-скрипт запустить без параметров, внутри контейнера будет вызван скрипт train_nn.R со значениями по умолчанию; если первый позиционный аргумент — это «bash», то контейнер запустится в интерактивном режиме с командной оболочкой. Во всех остальных случаях происходит подстановка значений позиционных аргументов: CMD="Rscript /app/train_nn.R $@".

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

7. Использование нескольких GPU в облаке Google Cloud

Една от особеностите на състезанието бяха доста шумните данни (вж. заглавната картинка, заета от @Leigh.plt от ODS-слека). За справяне с това помагат големи партиди, и след експерименти с компютър с 1 GPU решихме да се опитаме да обучим модели на няколко GPU в облака. Използвахме GoogleCloud (добро ръководство за основите на работа) заради голямото разнообразие от налични конфигурации, приемливи цени и бонус от $300. Поради жадност беше поръчан инстанс с 4xV100 с SSD и много RAM, и това се оказа голяма грешка. Парите такава машина бързо изразходва, при експерименти без отработен пайплайн може да се свършите. За учебни цели е по-добре да се вземат K80. Обаче голямото количество RAM се оказа полезно — облачният SSD не впечатли с бързодействието си, затова базата данни при всяко стартиране на инстанса пренасяхме на dev/shm.

Най-голям интерес представлява фрагментът от кода, отговарящ за използването на няколко GPU. Първо, моделът се създава на CPU, използвайки мениджър на контекста, съвсем както в Python:

with(tensorflow::tf$device("/cpu:0"), {
  model_cpu <- get_model(
    name = model_name,
    input_shape = input_shape,
    weights = weights,
    metrics = (top_3_categorical_accuracy,
    compile = FALSE
  )
})

След това нестабилният (това е важно) модел се копира на зададения брой налични GPU, и едва след това се компилира:

model <- keras::multi_gpu_model(model_cpu, gpus = n_gpu)
keras::compile(
  object = model,
  optimizer = keras::optimizer_adam(lr = 0.0004),
  loss = "categorical_crossentropy",
  metrics = c(top_3_categorical_accuracy)
)

Класическият подход с замразяване на всички слоеве, с изключение на последния, обучаването на последния слой, размразяването и дообучаването на целия модел за няколко GPU не успяхме да осъществим.

Следяхме обучението без използване на tensorboard, ограничени до запис на логове и запазване на модели с информативни имена след всяка епоха:

Колбеци

# Шаблон имени файла лога
log_file_tmpl <- file.path("logs", sprintf(
  "%s_%d_%dch_%s.csv",
  model_name,
  dim_size,
  channels,
  format(Sys.time(), "%Y%m%d%H%M%OS")
))
# Шаблон имени файла модели
model_file_tmpl <- file.path("models", sprintf(
  "%s_%d_%dch_{epoch:02d}_{val_loss:.2f}.h5",
  model_name,
  dim_size,
  channels
))

callbacks_list <- list(
  keras::callback_csv_logger(
    filename = log_file_tmpl
  ),
  keras::callback_early_stopping(
    monitor = "val_loss",
    min_delta = 1e-4,
    patience = 8,
    verbose = 1,
    mode = "min"
  ),
  keras::callback_reduce_lr_on_plateau(
    monitor = "val_loss",
    factor = 0.5, # уменьшаем lr в 2 раза
    patience = 4,
    verbose = 1,
    min_delta = 1e-4,
    mode = "min"
  ),
  keras::callback_model_checkpoint(
    filepath = model_file_tmpl,
    monitor = "val_loss",
    save_best_only = FALSE,
    save_weights_only = FALSE,
    mode = "min"
  )
)

8. Заключение

Редица проблеми, с които се сблъскахме, все още не успяхме да преодолеем:

• в keras няма готова функция за автоматично търсене на оптимална скорост на обучение (аналог на lr_finder в библиотеката fast.ai); вложените усилия могат да се използват, за да се пренесат странични реализации на R, например, тази;
• вследствие на предишната точка, не успяхме да подберем правилната скорост на обучение при използване на няколко GPU;
• не достигат съвременни архитектури на невронни мрежи, особено предварително обучени на ImageNet;
• няма one cycle policy и дискретни скорости на обучение (cosine annealing по нашата молба беше реализиран, благодаря skeydan).

Какво полезно успяхме да извлечем от това състезание:

• На сравнително слабо оборудване може безболезнено да работите с прилични (многократно превишаващи размера на RAM) обеми данни. Пакет data.table економи памет с in-place модификация на таблиците, което позволява да се избегне тяхното копиране, а при правилно използване на възможностите му почти винаги демонстрира най-висока скорост сред всички известни ни инструменти за скриптови езици. Съхраняването на данните в БД позволява в много случаи изобщо да не се мисли за необходимостта да се вмъква целият датасет в ОЗУ.
• Бавните функции на R могат да бъдат заменени с бързи на C++ чрез пакета Rcpp. Ако допълнително използваме RcppThread или RcppParallel, получаваме кросплатформени многопоточни реализации, така че кодът на ниво R не изисква паралелизиране.
• С пакета Rcpp може да се ползва без сериозни познания по C++, необходимият минимум е изложен тук. Заглавните файлове за редица мощни C-библиотеки като xtensor са налични в CRAN, така че се формира инфраструктура за реализиране на проекти, интегриращи готов код на C++ с висока производителност в R. Допълнителното удобство е синтактичният анализатор и статичен анализ на кода на C++ в RStudio.
• docopt позволява да се стартират самостоятелни скриптове с параметри. Това е удобно за използване на отдалечен сървър, включително под Docker. Провеждането на продължителни експерименти с обучение на невронни мрежи в RStudio е неудобно и самата инсталация на IDE на сървера не винаги е оправдана.
• Docker осигурява преносимост на кода и възпроизводимост на резултатите между разработчиците с различни версии на ОС и библиотеки, както и лесно стартиране на сървъри. Целият пайплайн за обучение може да бъде стартиран само с една команда.
• Google Cloud е икономически изгоден начин да експериментирате с скъпа техника, но е необходимо внимателно да се изберат конфигурациите.
• Измерването на скоростта на работа на отделни фрагменти код е много полезно, особено при съчетаване на R и C++, а с пакета bench — също и много лесно.

В заключение, този опит беше много полезен и продължаваме да работим върху решаването на някои от озвучените проблеми.

Източник: habr.com