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

Еј Хабр!

Минатата есен, Kaggle беше домаќин на натпревар за класификација на рачно нацртани слики, Quick Draw Doodle Recognition, во кој, меѓу другото, учествуваше и тим од Р-научници: Артем Клевцова, Менаџер на Филипа и Андреј Огурцов. Нема да го опишеме натпреварот во детали, тоа е веќе направено во неодамнешна публикација.

Овој пат не успеа со одгледување медали, но се стекна многу драгоцено искуство, па би сакал да и кажам на заедницата за голем број од најинтересните и најкорисните работи на Кагле и во секојдневната работа. Меѓу темите за кои се дискутираше: тежок живот без OpenCV, JSON парсирање (овие примери ја испитуваат интеграцијата на C++ кодот во скрипти или пакети во R користејќи Rcpp), параметаризација на скрипти и докеризација на конечното решение. Целиот код од пораката во форма погодна за извршување е достапен во складишта.

Содржина:

1. Ефикасно вчитајте податоци од CSV во MonetDB
2. Подготовка на серии
3. Итератори за истовар на серии од базата на податоци
4. Избор на модел на архитектура
5. Параметаризација на скрипта
6. Докеризација на скрипти
7. Користење на повеќе графички процесори на Google Cloud
8. Наместо заклучок

1. Ефикасно вчитајте податоци од CSV во базата на податоци на MonetDB

Податоците во овој натпревар не се обезбедени во форма на готови слики, туку во форма на 340 CSV датотеки (по една датотека за секоја класа) кои содржат JSON со координати на точки. Со поврзување на овие точки со линии, добиваме конечна слика со димензии 256x256 пиксели. Исто така, за секој запис има етикета што покажува дали сликата е правилно препознаена од класификаторот што се користел во моментот на собирање на базата, шифра со две букви на земјата на живеење на авторот на сликата, единствен идентификатор, временски печат и име на класа што се совпаѓа со името на датотеката. Поедноставената верзија на оригиналните податоци тежи 7.4 GB во архивата и приближно 20 GB по распакувањето, целосните податоци по распакувањето зафаќаат 240 GB. Организаторите се погрижија двете верзии да ги репродуцираат истите цртежи, што значи дека целосната верзија е излишна. Во секој случај, складирањето на 50 милиони слики во графички датотеки или во форма на низи веднаш се сметаше за непрофитабилно и решивме да ги споиме сите CSV-датотеки од архивата train_simplified.zip во базата на податоци со последователно генерирање на слики со потребната големина „во лет“ за секоја серија.

Добро докажан систем беше избран како DBMS 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_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. нјсон за парсирање на 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-конфигурација.

Имплементација на приклучокот 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 керас со неговите различни задни делови користејќи го истоимениот пакет, кој пак работи на врвот на пакетот мрежести. Вториот заслужува посебна долга статија; не само што ви овозможува да извршите Python код од R, туку исто така ви овозможува да пренесувате објекти помеѓу R и Python сесии, автоматски извршувајќи ги сите потребни конверзии на типови.

Се ослободивме од потребата да ги складираме сите податоци во RAM меморијата со помош на MonetDBLite, целата работа на „невронската мрежа“ ќе ја врши оригиналниот код во Python, само треба да напишеме итератор над податоците, бидејќи нема ништо подготвено за таква ситуација или во R или во Python. Во суштина има само две барања за него: мора да ги врати сериите во бескрајна јамка и да ја зачува својата состојба помеѓу повторувањата (второто во R се имплементира на наједноставен начин користејќи затворачи). Претходно, беше потребно експлицитно да се конвертираат R-низите во numpy низи внатре во итераторот, но тековната верзија на пакетот керас го прави тоа сама.

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

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

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], што се користеше при обука на испорачаните керас модели.

Надворешната функција содржи проверка на типот на аргументи, табела 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 и модификација преку врската - без овие пакети „чипови“ податоци. табела Прилично е тешко да се замисли да се работи ефективно со која било значителна количина на податоци во Р.

Резултатите од мерењето на брзината на лаптопот 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, чии карактеристики се дискутирани во ова порака. Стандардно е вклучено керас и, соодветно, е достапен во истоимениот пакет за 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)

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

Ние ги спроведовме повеќето експерименти користејќи ги мобилните верзии 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 од тековната верзија керас во Р употреба не мора да поради промените кои не се земени предвид во пакетот R, чекаме да го поправат.

Овој пристап овозможи значително да се забрзаат експериментите со различни модели во споредба со потрадиционалното лансирање на скрипти во RStudio (го забележуваме пакетот како можна алтернатива тфрунс). Но, главната предност е способноста лесно да се управува со лансирањето на скрипти во Docker или едноставно на серверот, без да се инсталира RStudio за ова.

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

Го користевме Docker за да обезбедиме преносливост на околината за модели за обука помеѓу членовите на тимот и за брзо распоредување во облакот. Можете да почнете да се запознавате со оваа алатка, која е релативно невообичаена за R програмер, со ова серија публикации или видео курс.

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

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

dockerfile

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 со стандардни вредности; ако првиот позиционен аргумент е „bash“, тогаш контејнерот ќе започне интерактивно со командна школка. Во сите други случаи, вредностите на позициските аргументи се заменуваат: CMD="Rscript /app/train_nn.R $@".

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

7. Користење на повеќе графички процесори на Google Cloud

Една од карактеристиките на натпреварот беа многу бучните податоци (видете ја насловната слика, позајмена од @Leigh.plt од ODS slack). Големите серии помагаат во борбата против ова, и по експериментите на компјутер со 1 графички процесор, решивме да ги совладаме моделите за обука на неколку графички процесори во облакот. Користев 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
  )
})

Потоа некомпајлираниот (ова е важно) модел се копира на даден број достапни графички процесори и само после тоа се компајлира:

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 во библиотеката брзо.ai); Со одреден напор, можно е да се префрлат имплементации од трети страни на R, на пример, ова;
• како последица на претходната точка, не беше можно да се избере точната брзина на обука при користење на неколку графички процесори;
• недостигаат модерни архитектури на невронски мрежи, особено оние кои се претходно обучени на имиџнет;
• Никој циклус политика и дискриминативни стапки на учење (косинусната жарење беше на наше барање имплементирани, Ви благодарам скејдан).

Кои корисни работи се научија од овој натпревар:

• На хардвер со релативно мала моќност, можете да работите со пристојни (многу пати поголеми од RAM меморијата) волумени на податоци без болка. Пластична кеса податоци. табела заштедува меморија поради наместената модификација на табелите, со што се избегнува нивно копирање, а кога се користи правилно, неговите способности речиси секогаш покажуваат најголема брзина меѓу сите алатки кои ни се познати за јазиците за скриптирање. Зачувувањето на податоците во базата на податоци ви овозможува, во многу случаи, воопшто да не размислувате за потребата да се притисне целата база на податоци во RAM меморијата.
• Бавните функции во R може да се заменат со брзи во C++ користејќи го пакетот Rcpp. Доколку покрај употребата RcppThread или RcppПаралелно, добиваме имплементации со повеќе нишки меѓу платформи, така што нема потреба да се паралелизира кодот на ниво R.
• Пакет Rcpp може да се користи без сериозно познавање на C++, наведен е потребниот минимум тука. Заглавие датотеки за голем број на кул C-библиотеки како xtensor достапен на CRAN, односно се формира инфраструктура за имплементација на проекти кои интегрираат готов C++ код со високи перформанси во Р. Дополнителна погодност е истакнувањето на синтаксата и статичниот C++ анализатор на кодови во RStudio.
• докопт ви овозможува да извршувате самостојни скрипти со параметри. Ова е погодно за употреба на оддалечен сервер, вкл. под докер. Во RStudio, незгодно е да се спроведуваат многу часови експерименти со обука на невронски мрежи, а инсталирањето на IDE на самиот сервер не е секогаш оправдано.
• Docker обезбедува преносливост на кодот и репродуктивност на резултатите помеѓу програмерите со различни верзии на ОС и библиотеки, како и леснотија на извршување на серверите. Можете да го стартувате целиот цевковод за обука со само една команда.
• Google Cloud е буџетски начин за експериментирање на скап хардвер, но треба внимателно да ги избирате конфигурациите.
• Мерењето на брзината на поединечните фрагменти од кодот е многу корисно, особено кога се комбинираат R и C++ и со пакетот клупата - исто така многу лесно.

Генерално, ова искуство беше многу наградувачко и ние продолжуваме да работиме на решавање на некои од покренатите прашања.

Извор: www.habr.com