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

Хей Хабр!

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

Този път не се получи с отглеждането на медали, но беше натрупан много ценен опит, така че бих искал да разкажа на общността за редица от най-интересните и полезни неща на Kagle и в ежедневната работа. Сред обсъжданите теми: труден живот без 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 GB в архива и приблизително 20 GB след разопаковане, пълните данни след разопаковане заемат 240 GB. Организаторите гарантираха, че и двете версии възпроизвеждат едни и същи рисунки, което означава, че пълната версия е излишна. Във всеки случай, съхраняването на 50 милиона изображения в графични файлове или под формата на масиви веднага беше счетено за нерентабилно и решихме да обединим всички CSV файлове от архива train_implified.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 - име на таблица и path - пътя до файла. По време на работа с архива беше открито, че вградената реализация 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 (DB) отнема по-малко от 10 минути.

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

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

message("Generate lables")
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("Generate row numbers")
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 на наблюдението. В оригиналния набор от данни типът, необходим за съхраняване на идентификатора, е 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
#        <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
# 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    49

ggplot(res_bench, aes(x = factor(batch_size), y = median, group = 1)) +
  geom_point() +
  geom_line() +
  ylab("median time, s") +
  theme_minimal()

DBI::dbDisconnect(con, shutdown = TRUE)

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

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

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

Като част от конкуренцията между ядрата на Python, проблемът беше решен предимно с помощта на OpenCV. Един от най-простите и очевидни аналози в 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, съхраняван в RAM (на Linux временните R директории се намират в директорията /tmp, монтиран в RAM). След това този файл се чете като триизмерен масив с числа, вариращи от 0 до 1. Това е важно, защото по-конвенционален BMP би бил прочетен в необработен масив с шестнадесетични цветови кодове.

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

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 пакета със същото име. Библиотеката ви позволява да работите с многоизмерни масиви, както в основен ред, така и в основен ред на колони.

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

4. RcppThread за организиране на многонишкова обработка на вектор от JSON. Използвани са заглавните файлове, предоставени от този пакет. От по-популярни RcppПаралелно Пакетът, наред с други неща, има вграден механизъм за прекъсване на цикъла.

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

Материали за изучаване на 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. За автоматично намиране на пътища и флагове използвахме популярна помощна програма на Linux 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 config for the pkg-config not found", 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
#   <chr>                <bch:tm>   <bch:tm>  <bch:tm>     <dbl>   <bch:tm>  <int>
# 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
#    <chr>             <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
#  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("median time, s") +
  theme_minimal() +
  scale_color_discrete(name = "", labels = c("cpp", "r")) +
  theme(legend.position = "bottom") 

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

3. Итератори за разтоварване на партиди от базата данни

R има заслужена репутация за обработка на данни, които се побират в RAM, докато Python се характеризира по-скоро с итеративна обработка на данни, което ви позволява лесно и естествено да прилагате изчисления извън ядрото (изчисления, използващи външна памет). Класически и уместен пример за нас в контекста на описания проблем са дълбоки невронни мрежи, обучени по метода на градиентно спускане с апроксимация на градиента на всяка стъпка, използвайки малка част от наблюдения или мини-партида.

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

Отървахме се от необходимостта да съхраняваме всички данни в RAM с помощта на 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++) и създаване на масиви, съответстващи на картини. След това се създават единични вектори с етикети на класове, масиви с пикселни стойности и етикети се комбинират в списък, който е връщаната стойност. За да ускорим работата, използвахме създаването на индекси в таблици 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
#        <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
# 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("median time, s") +
    theme_minimal()

DBI::dbDisconnect(con, shutdown = TRUE)

Ако имате достатъчно RAM, можете сериозно да ускорите работата на базата данни, като я прехвърлите в същата тази RAM (32 GB са достатъчни за нашата задача). В Linux дялът е монтиран по подразбиране /dev/shm, заемайки до половината от капацитета на RAM. Можете да подчертаете повече чрез редактиране /etc/fstabза да получите запис като tmpfs /dev/shm tmpfs defaults,size=25g 0 0. Не забравяйте да рестартирате и проверете резултата, като изпълните командата df -h.

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

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

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 <- function(object, 
                              filters,
                              alpha = 1,
                              depth_multiplier = 1,
                              strides = c(2, 2)) {

  # NB! depth_multiplier !=  resolution multiplier
  # https://github.com/keras-team/keras/issues/10349

  layer_depthwise_conv_2d(
    object = object,
    kernel_size = c(3, 3), 
    strides = strides,
    padding = "same",
    depth_multiplier = depth_multiplier
  ) %>%
  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 <- inputs %>%
    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 <- keras_model(
      inputs = inputs,
      outputs = outputs
    )

    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("Model ", shQuote(name), " not found.", 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. Параметризиране на скриптове

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

doc <- '
Usage:
  train_nn.R --help
  train_nn.R --list-models
  train_nn.R [options]

Options:
  -h --help                   Show this message.
  -l --list-models            List available models.
  -m --model=<model>          Neural network model name [default: mobilenet_v2].
  -b --batch-size=<size>      Batch size [default: 32].
  -s --scale-factor=<ratio>   Scale factor [default: 0.5].
  -c --color                  Use color lines [default: FALSE].
  -d --db-dir=<path>          Path to database directory [default: Sys.getenv("db_dir")].
  -r --validate-ratio=<ratio> Validate sample ratio [default: 0.995].
  -n --n-gpu=<number>         Number of GPUs [default: 1].
'
args <- docopt::docopt(doc)

пакет докопт представлява изпълнението 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 на трицветни изображения с размери 128x128 пиксела базата данни трябва да се намира в папката /home/andrey/doodle_db). Можете да добавите скорост на обучение, тип оптимизатор и всякакви други персонализирани параметри към списъка. В процеса на подготовка на изданието се оказа, че архитектурата mobilenet_v2 от текущата версия keras в R употреба не трябва поради промени, които не са взети предвид в R пакета, чакаме да го коригират.

Този подход направи възможно значително ускоряване на експериментите с различни модели в сравнение с по-традиционното стартиране на скриптове в RStudio (отбелязваме пакета като възможна алтернатива tfruns). Но основното предимство е възможността лесно да управлявате стартирането на скриптове в Docker или просто на сървъра, без да инсталирате RStudio за това.

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

Използвахме Docker, за да осигурим преносимост на средата за обучение на модели между членовете на екипа и за бързо внедряване в облака. Можете да започнете да се запознавате с този инструмент, който е сравнително необичаен за R програмист, с това поредица от публикации или видео курс.

Docker ви позволява както да създавате свои собствени изображения от нулата, така и да използвате други изображения като основа за създаване на свои собствени. Когато анализирахме наличните опции, стигнахме до извода, че инсталирането на NVIDIA, CUDA+cuDNN драйвери и библиотеки на Python е доста обемна част от изображението и решихме да вземем официалния образ като основа tensorflow/tensorflow:1.12.0-gpu, добавяйки необходимите R пакети там.

Крайният докер файл изглеждаше така:

Докер файл

FROM tensorflow/tensorflow:1.12.0-gpu

MAINTAINER Artem Klevtsov <[email protected]>

SHELL ["/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. Това избягва необходимостта да се указва версията на операционната система в кода.

Освен това беше написан малък bash скрипт, който ви позволява да стартирате контейнер с различни команди. Например, това могат да бъдат скриптове за обучение на невронни мрежи, които преди това са били поставени вътре в контейнера, или командна обвивка за отстраняване на грешки и наблюдение на работата на контейнера:

Скрипт за стартиране на контейнера

#!/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}

Ако този bash скрипт се изпълнява без параметри, скриптът ще бъде извикан вътре в контейнера train_nn.R със стойности по подразбиране; ако първият позиционен аргумент е "bash", тогава контейнерът ще стартира интерактивно с командна обвивка. Във всички останали случаи стойностите на позиционните аргументи се заместват: CMD="Rscript /app/train_nn.R $@".

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

7. Използване на множество GPU в Google Cloud

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

Най-голям интерес представлява кодовият фрагмент, отговорен за използването на множество графични процесори. Първо, моделът се създава на процесора с помощта на контекстен мениджър, точно както в 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 не можа да бъде приложена.

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

Обратни повиквания

# Шаблон имени файла лога
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 в библиотеката бързо.ai); С известни усилия е възможно да се пренесат реализации на трети страни към R, например, това;
• като следствие от предишната точка не беше възможно да се избере правилната скорост на обучение при използване на няколко графични процесора;
• липсват съвременни архитектури на невронни мрежи, особено тези, които са предварително обучени на imagenet;
• политика без един цикъл и дискриминативни нива на обучение (косинусното отгряване беше по наше искане изпълнени, Благодаря skeydan).

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

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

Като цяло това преживяване беше много полезно и ние продължаваме да работим за разрешаване на някои от повдигнатите проблеми.

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