Куицк Драв Доодле Рецогнитион: како се спријатељити са Р, Ц++ и неуронским мрежама

Хеј Хабр!

Прошле јесени, Каггле је био домаћин такмичења за класификацију ручно нацртаних слика, Куицк Драв Доодле Рецогнитион, у којем је, између осталих, учествовао и тим Р-научника: Артем Клевтсова, Пхилиппа Манагер и Андреј Огурцов. Нећемо детаљно описивати такмичење, то је већ урађено недавна публикација.

Овога пута није ишло са узгојем медаља, али је стечено много драгоценог искуства, па бих желео да испричам заједници неколико најзанимљивијих и најкориснијих ствари на Каглеу и у свакодневном раду. Међу темама о којима се разговарало: тежак живот без ОпенЦВ, ЈСОН рашчлањивање (ови примери испитују интеграцију Ц++ кода у скрипте или пакете у Р користећи Рцпп), параметризација скрипти и докеризација коначног решења. Сав код из поруке у облику погодном за извршење је доступан у спремишта.

Садржај:

1. Ефикасно учитајте податке из ЦСВ-а у МонетДБ
2. Припрема серија
3. Итератори за истовар пакета из базе података
4. Избор архитектуре модела
5. Параметеризација скрипте
6. Докеризација скрипти
7. Коришћење више ГПУ-а на Гоогле Цлоуд-у
8. Уместо закључка

1. Ефикасно учитајте податке из ЦСВ-а у МонетДБ базу података

Подаци у овом конкурсу нису дати у облику готових слика, већ у облику 340 ЦСВ фајлова (по један фајл за сваку класу) који садрже ЈСОН са координатама тачака. Повезивањем ових тачака линијама добијамо коначну слику димензија 256к256 пиксела. Такође за сваки запис постоји ознака која показује да ли је слику исправно препознао класификатор који је коришћен у време прикупљања скупа података, двословни код земље пребивалишта аутора слике, јединствени идентификатор, временска ознака и име класе које одговара имену датотеке. Поједностављена верзија оригиналних података тежи 7.4 ГБ у архиви и приближно 20 ГБ након распакивања, пуни подаци након распакивања заузимају 240 ГБ. Организатори су обезбедили да обе верзије репродукују исте цртеже, што значи да је пуна верзија сувишна. У сваком случају, складиштење 50 милиона слика у графичким датотекама или у облику низова одмах је сматрано неисплативим, па смо одлучили да спојимо све ЦСВ датотеке из архиве траин_симплифиед.зип у базу података са накнадним генерисањем слика потребне величине „у ходу“ за сваку серију.

Као ДБМС изабран је добро доказан систем МонетДБ, односно имплементација за Р као пакет МонетДБЛите. Пакет укључује уграђену верзију сервера базе података и омогућава вам да преузмете сервер директно из Р сесије и тамо радите са њим. Креирање базе података и повезивање са њом врши се једном командом:

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"
    )
  )
}

Најбржи начин за учитавање података у базу података био је директно копирање ЦСВ датотека помоћу СКЛ - команде COPY OFFSET 2 INTO tablename FROM path USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORTГде tablename - назив табеле и path - путања до датотеке. Током рада са архивом откривено је да је уграђена имплементација unzip у Р не ради исправно са већим бројем датотека из архиве, па смо користили систем 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

Време учитавања података може да варира у зависности од карактеристика брзине коришћеног драјва. У нашем случају, читање и писање унутар једног ССД-а или са флеш диска (изворне датотеке) на ССД (ДБ) траје мање од 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 трика. Први је био да се смањи димензионалност типа који чува ИД посматрања. У оригиналном скупу података, тип који је потребан за чување ИД-а је bigint, али број запажања омогућава да се њихови идентификатори, једнаки редном броју, уклопе у тип int. Претрага је у овом случају много бржа. Други трик је био коришћење ORDERED INDEX — до ове одлуке смо дошли емпиријски, прошавши све расположиве опције. Трећи је био коришћење параметризованих упита. Суштина методе је да се наредба изврши једном PREPARE уз накнадну употребу припремљеног израза при креирању гомиле упита истог типа, али у ствари постоји предност у поређењу са једноставним SELECT испоставило се да је у опсегу статистичке грешке.

Процес учитавања података не троши више од 450 МБ РАМ-а. То јест, описани приступ вам омогућава да премештате скупове података тежине десетине гигабајта на скоро сваки буџетски хардвер, укључујући и неке уређаје са једном плочом, што је прилично цоол.

Остаје само да измеримо брзину преузимања (случајних) података и проценимо скалирање приликом узорковања серија различитих величина:

Репер базе података

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. Парсирање неколико ЈСОН-ова који садрже векторе низова са координатама тачака.
2. Цртање линија у боји на основу координата тачака на слици потребне величине (на пример, 256×256 или 128×128).
3. Претварање добијених слика у тензор.

У оквиру такмичења међу Питхон кернелима, проблем је првенствено решен коришћењем ОпенЦВ. Један од најједноставнијих и најочигледнијих аналога у Р би изгледао овако:

Имплементација конверзије ЈСОН у тензор у Р

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)
}

Цртање се изводи помоћу стандардних Р алата и чува у привременом ПНГ формату који се чува у РАМ-у (на Линук-у, привремени Р директоријуми се налазе у директоријуму /tmp, монтиран у РАМ). Ова датотека се затим чита као тродимензионални низ са бројевима у распону од 0 до 1. Ово је важно јер би конвенционалнији БМП био прочитан у сирови низ са хексадецималним кодовима боја.

Хајде да тестирамо резултат:

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

Ова имплементација нам се чинила неоптимална, пошто формирање великих серија траје непристојно дуго, па смо одлучили да искористимо искуство наших колега коришћењем моћне библиотеке ОпенЦВ. У то време није постојао готов пакет за Р (сада га нема), па је минимална имплементација потребне функционалности написана у Ц++ са интеграцијом у Р код коришћењем Рцпп.

Да би се решио проблем, коришћени су следећи пакети и библиотеке:

1. ОпенЦВ за рад са сликама и цртање линија. Коришћене су унапред инсталиране системске библиотеке и датотеке заглавља, као и динамичко повезивање.

2. ктенсор за рад са вишедимензионалним низовима и тензорима. Користили смо датотеке заглавља укључене у истоимени Р пакет. Библиотека вам омогућава да радите са вишедимензионалним низовима, како у редовима, тако и у главном редоследу колона.

3. ндјсон за рашчлањивање ЈСОН-а. Ова библиотека се користи у ктенсор аутоматски ако је присутан у пројекту.

4. РцппТхреад за организовање вишенитне обраде вектора из ЈСОН-а. Користио је датотеке заглавља које обезбеђује овај пакет. Од популарнијих РцппПараллел Пакет, између осталог, има уграђен механизам за прекид петље.

Треба напоменути да ктенсор испоставило се да је божји дар: поред чињенице да има широку функционалност и високе перформансе, испоставило се да су његови програмери прилично реаговали и одговорили на питања брзо и детаљно. Уз њихову помоћ, било је могуће реализовати трансформације ОпенЦВ матрица у ктензор тензора, као и начин комбиновања 3-димензионалних тензора слике у 4-димензионални тензор исправне димензије (сама серија).

Материјали за учење Рцпп, ктенсор и РцппТхреад

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::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"

Имплементациони код за рашчлањивање ЈСОН-а и генерисање групе за пренос у модел је дат испод спојлера. Прво додајте локални директоријум пројекта да бисте тражили датотеке заглавља (потребно за ндјсон):

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

Имплементација конверзије ЈСОН у тензор у Ц++

// [[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 — функција анализира ЈСОН стринг, издваја координате тачака, пакује их у вектор;

• ocv_draw_lines — из резултујућег вектора тачака, црта вишебојне линије;

• process — комбинује горе наведене функције и такође додаје могућност скалирања резултирајуће слике;

• cpp_process_json_str - омотач преко функције process, који извози резултат у Р-објекат (вишедимензионални низ);

• cpp_process_json_vector - омотач преко функције cpp_process_json_str, који вам омогућава да обрађујете вектор низа у вишенитном режиму.

За цртање вишебојних линија коришћен је ХСВ модел боја, након чега је уследила конверзија у РГБ. Хајде да тестирамо резултат:

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

Поређење брзине имплементација у Р и Ц++

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") 

Као што видите, повећање брзине се показало веома значајним и није могуће сустићи Ц++ код паралелизацијом Р кода.

3. Итератори за истовар партија из базе података

Р има заслужену репутацију за обраду података који се уклапају у РАМ, док Питхон више карактерише итеративна обрада података, што вам омогућава да лако и природно имплементирате прорачуне ван језгра (прорачуни помоћу екстерне меморије). Класичан и релевантан пример за нас у контексту описаног проблема су дубоке неуронске мреже обучене методом градијента спуштања са апроксимацијом градијента на сваком кораку користећи мали део посматрања, или мини-батцх.

Оквири за дубоко учење написани у Питхон-у имају посебне класе које имплементирају итераторе на основу података: табеле, слике у фасциклама, бинарни формати, итд. Можете користити готове опције или написати своје за одређене задатке. У Р можемо искористити све карактеристике Питхон библиотеке керас са својим различитим позадинама користећи истоимени пакет, који заузврат ради на врху пакета мрежасти. Ово последње заслужује посебан дуг чланак; не само да вам омогућава да покренете Питхон код из Р, већ вам такође омогућава да преносите објекте између Р и Питхон сесија, аутоматски обављајући све потребне конверзије типова.

Решили смо се потребе да чувамо све податке у РАМ-у коришћењем МонетДБЛите-а, сав посао на „неуралној мрежи“ ће обављати оригинални код у Питхон-у, само морамо да напишемо итератор преко података, пошто ништа није спремно за такву ситуацију у Р или Питхон-у. У суштини постоје само два захтева за њега: мора да враћа пакете у бесконачној петљи и да сачува своје стање између итерација (ово последње у Р се имплементира на најједноставнији начин коришћењем затварања). Раније је било потребно експлицитно конвертовати Р низове у нумпи низове унутар итератора, али тренутна верзија пакета керас сама то ради.

Показало се да је итератор за податке о обуци и валидацији следећи:

Итератор за обуку и валидацију података

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 одговара приказивању слика од 256к256 пиксела, scale = 0.5 — 128к128 пиксела), индикатор боја (color = FALSE одређује приказивање у сивим тоновима када се користи color = TRUE сваки потез је нацртан у новој боји) и индикатор за претходну обраду за мреже претходно обучене на имагенет-у. Ово последње је потребно да би се скалирали вредности пиксела од интервала [0, 1] до интервала [-1, 1], који је коришћен при обучавању испоручених керас модели.

Екстерна функција садржи проверу типа аргумента, табелу data.table са насумично помешаним бројевима линија из samples_index и бројеви серија, бројач и максималан број серија, као и СКЛ израз за истовар података из базе података. Додатно, дефинисали смо брзи аналог функције унутра keras::to_categorical(). Користили смо скоро све податке за обуку, остављајући пола процента за валидацију, тако да је величина епохе била ограничена параметром steps_per_epoch приликом позивања keras::fit_generator(), и стање if (i > max_i) радио само за итератор валидације.

У интерној функцији, индекси редова се преузимају за следећу групу, записи се учитавају из базе података са повећањем бројача групе, ЈСОН рашчлањивањем (функција cpp_process_json_vector(), написан у Ц++) и креирање низова који одговарају сликама. Затим се креирају једнократни вектори са ознакама класа, низови са вредностима пиксела и ознакама се комбинују у листу, што је повратна вредност. Да бисмо убрзали рад, користили смо креирање индекса у табелама data.table и модификација преко везе - без ових пакета „чипова“ подаци.табела Прилично је тешко замислити ефикасан рад са било којом значајном количином података у Р.

Резултати мерења брзине на Цоре и5 лаптопу су следећи:

Бенцхмарк итератора

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)

Ако имате довољну количину РАМ-а, можете озбиљно убрзати рад базе података тако што ћете је пренети у ову исту РАМ меморију (за наш задатак је довољно 32 ГБ). У Линук-у, партиција је подразумевано монтирана /dev/shm, који заузимају до половине капацитета РАМ-а. Можете да истакнете више уређивањем /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. Избор архитектуре модела

Прва коришћена архитектура била је мобиленет в1, о чијим карактеристикама се говори у ово порука. Укључен је као стандард керас и, сходно томе, доступан је у истоименом пакету за Р. Али када покушате да га користите са једноканалним сликама, испоставило се чудно: улазни тензор увек мора имати димензију (batch, height, width, 3), односно број канала се не може мењати. У Питхон-у нема таквог ограничења, па смо пожурили и написали сопствену имплементацију ове архитектуре, пратећи оригинални чланак (без испадања који је у керас верзији):

Мобиленет в1 архитектура

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)
}

Недостаци овог приступа су очигледни. Желим да тестирам много модела, али напротив, не желим да преписујем сваку архитектуру ручно. Такође смо били лишени могућности да користимо тежине модела унапред обучених на имагенет-у. Као и обично, помогло је проучавање документације. Функција get_config() омогућава вам да добијете опис модела у облику погодном за уређивање (base_model_conf$layers - регуларна Р листа) и функција 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)

Сада није тешко написати универзалну функцију за добијање било које од испоручених керас модели са или без тегова обучени на имагенет-у:

Функција за учитавање готових архитектура

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() добијте тежине модела у облику листе Р низова, промените димензију првог елемента ове листе (узимањем једног канала боје или усредњавањем сва три), а затим учитајте тежине назад у модел помоћу функције set_weights(). Никада нисмо додали ову функционалност, јер је у овој фази већ било јасно да је продуктивније радити са сликама у боји.

Извели смо већину експеримената користећи мобилне мреже верзије 1 и 2, као и реснет34. Модерније архитектуре као што је СЕ-РесНеКст су се добро показале на овом такмичењу. Нажалост, нисмо имали готове имплементације на располагању, а нисмо ни писали своје (али ћемо свакако писати).

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/ за Р. Уз његову помоћ, скрипте се покрећу једноставним командама попут 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 из тренутне верзије керас у употреби Р не могу због промена које нису узете у обзир у Р пакету, чекамо да то поправе.

Овај приступ је омогућио да се значајно убрзају експерименти са различитим моделима у поређењу са традиционалнијим покретањем скрипти у РСтудиу (пакет наводимо као могућу алтернативу тфрунс). Али главна предност је могућност лаког управљања покретањем скрипти у Доцкер-у или једноставно на серверу, без инсталирања РСтудиа за ово.

6. Докеризација скрипти

Користили смо Доцкер да обезбедимо преносивост окружења за моделе обуке између чланова тима и за брзу примену у облаку. Можете почети да се упознате са овим алатом, који је релативно необичан за Р програмера ово серија публикација или видео курс.

Доцкер вам омогућава да креирате сопствене слике од нуле и да користите друге слике као основу за креирање сопствених. Анализирајући доступне опције, дошли смо до закључка да је инсталирање НВИДИА, ЦУДА+цуДНН драјвера и Питхон библиотека прилично обимни део слике и одлучили смо да за основу узмемо званичну слику tensorflow/tensorflow:1.12.0-gpu, додајући тамо потребне Р пакете.

Коначна доцкер датотека је изгледала овако:

Доцкерфиле

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. Тиме је избегнута потреба да се у коду наведе верзија ОС-а.

Поред тога, написана је мала басх скрипта која вам омогућава да покренете контејнер са различитим командама. На пример, то могу бити скрипте за обуку неуронских мрежа које су претходно биле смештене унутар контејнера, или командна шкољка за отклањање грешака и надгледање рада контејнера:

Скрипта за покретање контејнера

#!/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 са подразумеваним вредностима; ако је први позициони аргумент "басх", онда ће контејнер започети интерактивно са командном шкољком. У свим осталим случајевима, вредности позиционих аргумената се замењују: CMD="Rscript /app/train_nn.R $@".

Вреди напоменути да се директоријуми са изворним подацима и базом података, као и директоријум за чување обучених модела, монтирају унутар контејнера из хост система, што вам омогућава да приступите резултатима скрипти без непотребних манипулација.

7. Коришћење више ГПУ-а на Гоогле Цлоуд-у

Једна од карактеристика такмичења су били веома бучни подаци (погледајте насловну слику, позајмљену са @Леигх.плт из ОДС слацк-а). Велике серије помажу у борби против овога, и након експеримената на рачунару са 1 ГПУ-ом, одлучили смо да савладамо моделе обуке на неколико ГПУ-а у облаку. Користи ГооглеЦлоуд (добар водич за основе) због великог избора доступних конфигурација, разумних цена и бонуса од 300 УСД. Из похлепе, наручио сам 4кВ100 инстанцу са ССД-ом и тоном РАМ-а, и то је била велика грешка. Таква машина брзо поједе новац; можете пропасти експериментишући без доказаног цевовода. У образовне сврхе, боље је узети К80. Али велика количина РАМ-а је добро дошла - цлоуд ССД није импресионирао својим перформансама, па је база података пребачена на dev/shm.

Највећи интерес је фрагмент кода одговоран за коришћење више ГПУ-ова. Прво, модел се креира на ЦПУ-у помоћу менаџера контекста, баш као у Питхон-у:

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
  )
})

Затим се непреведени (ово је важно) модел копира на дати број доступних ГПУ-а и тек након тога се компајлира:

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)
)

Класична техника замрзавања свих слојева осим последњег, обучавања последњег слоја, одмрзавања и преобуке целог модела за неколико ГПУ-а није могла да се примени.

Обука је праћена без употребе. тенсорбоард, ограничавајући се на снимање дневника и чување модела са информативним називима након сваке епохе:

Повратни позиви

# Шаблон имени файла лога
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. Уместо закључка

Бројни проблеми са којима смо се сусрели још увек нису превазиђени:

• в керас не постоји готова функција за аутоматско тражење оптималне брзине учења (аналогно lr_finder у библиотеци брзо.аи); Уз одређени напор, могуће је пренети имплементације треће стране на Р, на пример, ово;
• као последица претходне тачке, није било могуће изабрати исправну брзину тренинга када се користи неколико ГПУ-а;
• постоји недостатак модерних архитектура неуронских мрежа, посебно оних претходно обучених на имагенет-у;
• политика једног циклуса и дискриминативне стопе учења (косинусно жарење је било на наш захтев имплементиран, Хвала скеидан).

Шта се корисно научило са овог такмичења:

• На хардверу са релативно малом потрошњом, можете да радите са пристојним (вишеструко већим од РАМ-а) обимима података без муке. Пластична кеса подаци.табела штеди меморију захваљујући модификацији табела на месту, чиме се избегава њихово копирање, а када се правилно користе, његове могућности скоро увек показују највећу брзину међу свим нама познатим алатима за скриптне језике. Чување података у бази података вам омогућава, у многим случајевима, да уопште не размишљате о потреби да се цео скуп података угура у РАМ.
• Споре функције у Р могу се заменити брзим у Ц++ помоћу пакета Рцпп. Ако поред употребе РцппТхреад или РцппПараллел, добијамо вишеплатформске имплементације са више нити, тако да нема потребе за паралелизацијом кода на нивоу Р.
• Пакет Рцпп може се користити без озбиљног познавања Ц++-а, наведен је потребан минимум овде. Датотеке заглавља за бројне цоол Ц-библиотеке као што су ктенсор доступно на ЦРАН-у, односно формира се инфраструктура за имплементацију пројеката који интегришу готов Ц++ код високих перформанси у Р. Додатна погодност је истицање синтаксе и статички Ц++ анализатор кода у РСтудиу.
• доцопт омогућава вам да покренете самосталне скрипте са параметрима. Ово је згодно за употребу на удаљеном серверу, укљ. под доцкер. У РСтудиу је незгодно изводити много сати експеримената са обучавањем неуронских мрежа, а инсталирање ИДЕ-а на самом серверу није увек оправдано.
• Доцкер обезбеђује преносивост кода и поновљивост резултата између програмера са различитим верзијама ОС-а и библиотека, као и лакоћу извршавања на серверима. Можете покренути цео цевовод обуке са само једном командом.
• Гоогле Цлоуд је јефтин начин за експериментисање на скупом хардверу, али морате пажљиво да изаберете конфигурације.
• Мерење брзине појединачних фрагмената кода је веома корисно, посебно када се комбинују Р и Ц++, и са пакетом клупа - такође врло лако.

Све у свему, ово искуство је било веома корисно и настављамо да радимо на решавању неких од постављених питања.

Извор: ввв.хабр.цом