Quick Draw Doodle Recognition: R, C++ 및 신경망과 친구가 되는 방법

헤이 하브르!

지난 가을 Kaggle은 손으로 그린 ​​그림을 분류하는 대회인 Quick Draw Doodle Recognition을 주최했으며, 여기에는 R 과학자 팀이 참여했습니다. 아르템 클레프초바, 필리파 매니저 и 안드레이 오구르초프. 우리는 경쟁에 대해 자세히 설명하지 않을 것입니다. 최근 출판물.

이번에는 메달 파밍이 잘 안 됐지만, 귀중한 경험을 많이 쌓았기 때문에 Kagle과 일상 업무에서 가장 흥미롭고 유용한 여러 가지 사항을 커뮤니티에 알리고 싶습니다. 논의된 주제 중: 없이는 어려운 삶 OpenCV, JSON 구문 분석(이 예제에서는 다음을 사용하여 C++ 코드를 R의 스크립트 또는 패키지에 통합하는 방법을 검사합니다. RCPP), 스크립트의 매개변수화 및 최종 솔루션의 Docker화. 실행에 적합한 형태의 메시지의 모든 코드는 다음에서 사용할 수 있습니다. 저장소.

Содержание :

1. CSV의 데이터를 MonetDB로 효율적으로 로드
2. 배치 준비
3. 데이터베이스에서 배치를 언로드하기 위한 반복자
4. 모델 아키텍처 선택
5. 스크립트 매개변수화
6. 스크립트의 Docker화
7. Google Cloud에서 여러 GPU 사용
8. 대신 결론

1. CSV의 데이터를 MonetDB 데이터베이스로 효율적으로 로드

본 공모전의 데이터는 기성 이미지 형태가 아닌, 점좌표가 포함된 JSON을 포함하는 340개의 CSV 파일(클래스당 256개 파일) 형태로 제공됩니다. 이 점들을 선으로 연결하면 256x7.4 픽셀 크기의 최종 이미지를 얻을 수 있습니다. 또한 각 레코드에는 데이터 세트 수집 시 사용된 분류자가 사진을 올바르게 인식했는지 여부를 나타내는 레이블, 사진 작성자의 거주 국가에 대한 20자리 코드, 고유 식별자, 타임스탬프가 있습니다. 파일 이름과 일치하는 클래스 이름입니다. 원본 데이터의 단순화된 버전은 아카이브에서 240GB이고 압축을 푼 후 약 50GB이며, 압축을 푼 후 전체 데이터는 XNUMXGB를 차지합니다. 주최측은 두 버전 모두 동일한 그림을 재현했는지 확인했는데, 이는 전체 버전이 중복되었음을 의미합니다. 어쨌든 XNUMX천만 개의 이미지를 그래픽 파일이나 배열 형태로 저장하는 것은 즉시 수익성이 없는 것으로 간주되어 아카이브의 모든 CSV 파일을 병합하기로 결정했습니다. train_simplified.zip 각 배치에 대해 "즉시" 필요한 크기의 이미지를 후속 생성하여 데이터베이스에 저장합니다.

검증된 시스템이 DBMS로 선택되었습니다. 모넷DB, 즉 R을 패키지로 구현한 것입니다. 모네DBLite. 패키지에는 데이터베이스 서버의 내장 버전이 포함되어 있으며 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"
    )
  )
}

데이터베이스에 데이터를 로드하는 가장 빠른 방법은 SQL - 명령을 사용하여 CSV 파일을 직접 복사하는 것이었습니다. 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를 저장하는 유형의 차원을 줄이는 것이었습니다. 원본 데이터 세트에서 ID를 저장하는 데 필요한 유형은 다음과 같습니다. bigint, 그러나 관측치 수를 통해 서수와 동일한 식별자를 유형에 맞출 수 있습니다. int. 이 경우 검색이 훨씬 빠릅니다. 두 번째 비결은 다음과 같습니다. ORDERED INDEX — 우리는 가능한 모든 방법을 검토한 후 경험적으로 이 결정을 내렸습니다. 옵션들. 세 번째는 매개변수화된 쿼리를 사용하는 것이었습니다. 이 방법의 핵심은 명령을 한 번 실행하는 것입니다. PREPARE 동일한 유형의 쿼리를 여러 개 생성할 때 준비된 표현식을 나중에 사용하지만 실제로는 간단한 쿼리에 비해 이점이 있습니다. SELECT 통계오차 범위 내인 것으로 나타났다.

데이터 업로드 프로세스는 450MB 이하의 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에서 가장 간단하고 가장 분명한 유사점 중 하나는 다음과 같습니다.

R에서 JSON을 Tensor로 변환 구현

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 도구를 사용하여 수행되며 RAM에 저장된 임시 PNG에 저장됩니다(Linux에서는 임시 R 디렉터리가 디렉터리에 있음). /tmp, RAM에 마운트됨). 그런 다음 이 파일은 0에서 1까지의 숫자를 가진 XNUMX차원 배열로 읽혀집니다. 보다 일반적인 BMP는 XNUMX진수 색상 코드가 있는 원시 배열로 읽혀지기 때문에 이는 중요합니다.

결과를 테스트해 보겠습니다.

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용 기성 패키지가 없었으므로(현재는 없음) 필요한 기능의 최소한의 구현이 다음을 사용하여 R 코드에 통합된 C++로 작성되었습니다. RCPP.

문제를 해결하기 위해 다음 패키지와 라이브러리가 사용되었습니다.

1. OpenCV 이미지 작업 및 선 그리기에 사용됩니다. 사전 설치된 시스템 라이브러리와 헤더 파일은 물론 동적 링크도 사용되었습니다.

2. 엑스텐서 다차원 배열 및 텐서 작업에 사용됩니다. R 패키지에 포함된 동일한 이름의 헤더 파일을 사용했습니다. 라이브러리를 사용하면 행 주요 순서와 열 주요 순서 모두에서 다차원 배열로 작업할 수 있습니다.

3. ndjson JSON을 구문 분석하기 위한 것입니다. 이 라이브러리는 다음에서 사용됩니다. 엑스텐서 프로젝트에 있으면 자동으로.

4. Rcpp스레드 JSON에서 벡터의 멀티스레드 처리를 구성하기 위한 것입니다. 이 패키지에서 제공하는 헤더 파일을 사용했습니다. 더 인기있는 것부터 Rcpp병렬 무엇보다도 패키지에는 루프 인터럽트 메커니즘이 내장되어 있습니다.

그것은 언급되어야 엑스텐서 신의 선물로 판명되었습니다. 광범위한 기능과 고성능을 갖추고 있다는 사실 외에도 개발자는 반응이 빠르고 질문에 신속하고 자세하게 답변했습니다. 이들의 도움으로 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 유틸리티를 사용했습니다. 패키지 구성.

OpenCV 라이브러리를 사용하기 위한 Rcpp 플러그인 구현

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

C++에서 JSON을 텐서로 변환하는 구현

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

보시다시피 속도 향상이 매우 컸으며 R 코드를 병렬화하여 C++ 코드를 따라잡는 것은 불가능합니다.

3. 데이터베이스에서 배치를 언로드하기 위한 반복자

R은 RAM에 맞는 데이터를 처리하는 것으로 정평이 나있는 반면, Python은 반복적인 데이터 처리가 특징으로 아웃오브코어 계산(외부 메모리를 사용한 계산)을 쉽고 자연스럽게 구현할 수 있습니다. 설명된 문제의 맥락에서 우리에게 고전적이고 관련 있는 예는 관찰의 작은 부분 또는 미니 배치를 사용하여 각 단계에서 경사를 근사화하는 경사하강법으로 훈련된 심층 신경망입니다.

Python으로 작성된 딥 러닝 프레임워크에는 데이터(테이블, 폴더의 그림, 바이너리 형식 등)를 기반으로 반복자를 구현하는 특수 클래스가 있습니다. 미리 만들어진 옵션을 사용하거나 특정 작업을 위해 직접 작성할 수 있습니다. R에서는 Python 라이브러리의 모든 기능을 활용할 수 있습니다. 케 라스 동일한 이름의 패키지를 사용하는 다양한 백엔드가 있으며, 이는 패키지 위에서 작동합니다. 망상하다. 후자는 별도의 긴 기사가 필요합니다. 이를 통해 R에서 Python 코드를 실행할 수 있을 뿐만 아니라 R과 Python 세션 간에 개체를 전송하여 필요한 모든 유형 변환을 자동으로 수행할 수 있습니다.

MonetDBLite를 사용하여 RAM에 모든 데이터를 저장할 필요성을 없앴습니다. 모든 "신경망" 작업은 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(). 훈련에 거의 모든 데이터를 사용하고 검증을 위해 XNUMX%만 남겨두었으므로 에포크 크기는 매개변수에 의해 제한되었습니다. steps_per_epoch 부를 때 keras::fit_generator(), 및 조건 if (i > max_i) 유효성 검사 반복자에 대해서만 작동했습니다.

내부 함수에서는 다음 배치에 대한 행 인덱스가 검색되고, 배치 카운터가 증가하면서 데이터베이스에서 레코드가 언로드되고, JSON 구문 분석(함수 cpp_process_json_vector(), C++로 작성됨) 및 그림에 해당하는 배열을 생성합니다. 그런 다음 클래스 레이블이 있는 원-핫 벡터가 생성되고 픽셀 값과 레이블이 있는 배열이 반환 값인 목록으로 결합됩니다. 작업 속도를 높이기 위해 테이블에 인덱스 생성을 사용했습니다. data.table 링크를 통한 수정 - 이러한 패키지 "칩" 없이 데이터 테이블 R에서 상당한 양의 데이터를 효과적으로 작업하는 것은 상상하기 매우 어렵습니다.

Core i5 노트북의 속도 측정 결과는 다음과 같습니다.

반복자 벤치마크

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

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

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

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

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

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

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

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

DBI::dbDisconnect(con, shutdown = TRUE)

충분한 양의 RAM이 있는 경우 데이터베이스를 동일한 RAM으로 전송하여 데이터베이스 작업 속도를 크게 높일 수 있습니다(우리 작업에는 32GB이면 충분합니다). 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. 모델 아키텍처 선택

처음으로 사용된 아키텍처는 모바일넷 v1, 그 기능은 다음에서 논의됩니다. 이 메시지. 기본으로 포함되어 있어요 케 라스 따라서 R과 동일한 이름의 패키지에서 사용할 수 있습니다. 그러나 단일 채널 이미지와 함께 사용하려고 하면 이상한 결과가 나왔습니다. 입력 텐서는 항상 다음 차원을 가져야 합니다. (batch, height, width, 3)즉, 채널 수를 변경할 수 없습니다. Python에는 그러한 제한이 없으므로 우리는 원본 기사에 따라 이 아키텍처의 자체 구현을 서둘러 작성했습니다(keras 버전에 있는 드롭아웃 없음).

모바일넷 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(). 우리는 이 기능을 추가하지 않았습니다. 왜냐하면 이 단계에서 컬러 사진으로 작업하는 것이 더 생산적이라는 것이 이미 분명했기 때문입니다.

우리는 resnet1뿐만 아니라 mobilenet 버전 2과 34를 사용하여 대부분의 실험을 수행했습니다. 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 픽셀 크기의 XNUMX색 이미지의 경우 데이터베이스가 폴더에 있어야 합니다. /home/andrey/doodle_db). 학습 속도, 최적화 유형 및 기타 사용자 정의 가능한 매개변수를 목록에 추가할 수 있습니다. 출판물을 준비하는 과정에서 아키텍처가 mobilenet_v2 현재 버전부터 케 라스 R 사용에서 이러지마 R 패키지에서 고려되지 않은 변경 사항으로 인해 수정을 기다리고 있습니다.

이 접근 방식을 사용하면 RStudio에서 보다 전통적인 스크립트를 시작하는 것과 비교하여 다양한 모델을 사용한 실험 속도를 크게 높일 수 있습니다(가능한 대안으로 패키지를 언급합니다). 트프런). 그러나 가장 큰 장점은 이를 위해 RStudio를 설치하지 않고도 Docker 또는 단순히 서버에서 스크립트 실행을 쉽게 관리할 수 있다는 것입니다.

6. 스크립트 도커화

우리는 Docker를 사용하여 팀 구성원 간 모델 교육과 클라우드에서의 신속한 배포를 위한 환경 이식성을 보장했습니다. R 프로그래머에게는 상대적으로 특이한 이 도구에 익숙해지기 시작할 수 있습니다. 이 일련의 출판물이나 비디오 코스.

Docker를 사용하면 처음부터 자신만의 이미지를 생성하고 다른 이미지를 기반으로 자신만의 이미지를 생성할 수 있습니다. 사용 가능한 옵션을 분석한 결과 NVIDIA, CUDA+cuDNN 드라이버 및 Python 라이브러리를 설치하는 것이 이미지에서 상당히 많은 부분을 차지한다는 결론에 도달했으며 공식 이미지를 기반으로 사용하기로 결정했습니다. tensorflow/tensorflow:1.12.0-gpu, 거기에 필요한 R 패키지를 추가합니다.

최종 도커 파일은 다음과 같습니다.

도커 파일

FROM tensorflow/tensorflow:1.12.0-gpu

MAINTAINER Artem Klevtsov <[email protected]>

SHELL ["/bin/bash", "-c"]

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

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

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

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

WORKDIR /app

VOLUME /db
VOLUME /app

CMD bash

편의상 사용된 패키지를 변수에 넣었습니다. 작성된 스크립트의 대부분은 조립 중에 컨테이너 내부에 복사됩니다. 또한 명령 셸을 다음으로 변경했습니다. /bin/bash 콘텐츠 이용의 편의성을 위해 /etc/os-release. 이렇게 하면 코드에서 OS 버전을 지정할 필요가 없습니다.

또한 다양한 명령으로 컨테이너를 시작할 수 있는 작은 bash 스크립트가 작성되었습니다. 예를 들어 이전에 컨테이너 내부에 배치된 신경망을 훈련하기 위한 스크립트이거나 컨테이너 작업을 디버깅하고 모니터링하기 위한 명령 셸일 수 있습니다.

컨테이너를 시작하는 스크립트

#!/bin/sh

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

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

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

이 bash 스크립트를 매개변수 없이 실행하면 스크립트가 컨테이너 내부에서 호출됩니다. train_nn.R 기본값으로; 첫 번째 위치 인수가 "bash"이면 컨테이너는 명령 셸과 대화형으로 시작됩니다. 다른 모든 경우에는 위치 인수의 값이 대체됩니다. CMD="Rscript /app/train_nn.R $@".

소스 데이터와 데이터베이스가 있는 디렉터리와 훈련된 모델을 저장하기 위한 디렉터리가 호스트 시스템의 컨테이너 내부에 마운트되어 불필요한 조작 없이 스크립트 결과에 액세스할 수 있다는 점은 주목할 가치가 있습니다.

7. Google Cloud에서 여러 GPU 사용

대회의 특징 중 하나는 매우 시끄러운 데이터였습니다(ODS Slack의 @Leigh.plt에서 가져온 제목 사진 참조). 대규모 배치는 이 문제를 해결하는 데 도움이 되며, 1개의 GPU가 있는 PC에서 실험한 후 클라우드의 여러 GPU에서 학습 모델을 마스터하기로 결정했습니다. 중고 GoogleCloud(기본에 대한 좋은 가이드) 사용 가능한 구성이 다양하고 합리적인 가격과 $300의 보너스가 제공됩니다. 욕심 때문에 SSD와 엄청난 양의 RAM이 포함된 4xV100 인스턴스를 주문했는데, 그건 큰 실수였습니다. 이러한 기계는 돈을 빨리 소모하므로 입증된 파이프라인 없이 실험하면 파산할 수 있습니다. 교육 목적으로는 K80을 사용하는 것이 좋습니다. 그러나 대용량 RAM이 유용했습니다. 클라우드 SSD는 성능이 인상적이지 않았기 때문에 데이터베이스가 다음으로 전송되었습니다. dev/shm.

가장 흥미로운 것은 다중 GPU 사용을 담당하는 코드 조각입니다. 먼저 모델은 Python에서와 마찬가지로 컨텍스트 관리자를 사용하여 CPU에서 생성됩니다.

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

그런 다음 컴파일되지 않은(중요) 모델이 주어진 수의 사용 가능한 GPU에 복사되고 그 후에만 컴파일됩니다.

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

마지막 레이어를 제외한 모든 레이어를 동결하고, 마지막 레이어를 훈련하고, 여러 GPU에 대해 전체 모델을 동결 해제하고 다시 훈련하는 고전적인 기술은 구현할 수 없었습니다.

훈련은 사용하지 않고 모니터링되었습니다. 텐서 보드, 로그를 기록하고 각 시대 이후에 유익한 이름으로 모델을 저장하는 것으로 제한합니다.

콜백

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

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

8. 결론 대신

우리가 직면한 여러 가지 문제는 아직 해결되지 않았습니다.

• в 케 라스 최적의 학습률을 자동으로 검색하는 기성 기능이 없습니다(아날로그 lr_finder 도서관에서 fast.ai); 약간의 노력을 기울이면 제XNUMX자 구현을 R로 이식하는 것이 가능합니다. 예를 들면 다음과 같습니다. 이;
• 이전 요점의 결과로 여러 GPU를 사용할 때 올바른 훈련 속도를 선택할 수 없었습니다.
• 현대 신경망 아키텍처, 특히 imagenet에서 사전 훈련된 아키텍처가 부족합니다.
• 무주기 정책과 차별적인 학습률(코사인 어닐링은 우리의 요청에 따라 이루어졌습니다) 구현고마워. 스카이단).

이번 대회에서 배운 유용한 점은 무엇입니까?

• 상대적으로 저전력 하드웨어에서는 상당한 양(RAM 크기의 몇 배)의 데이터를 문제 없이 작업할 수 있습니다. 비닐 봉투 데이터 테이블 테이블 복사를 방지하는 내부 수정으로 인해 메모리를 절약하고 올바르게 사용하면 그 기능은 거의 항상 스크립팅 언어에 대해 알려진 모든 도구 중에서 가장 빠른 속도를 보여줍니다. 데이터베이스에 데이터를 저장하면 많은 경우 전체 데이터 세트를 RAM에 압축할 필요성에 대해 전혀 생각하지 않아도 됩니다.
• R의 느린 함수는 패키지를 사용하여 C++의 빠른 함수로 대체될 수 있습니다. RCPP. 추가적으로 사용한다면 Rcpp스레드 또는 Rcpp병렬, 크로스 플랫폼 다중 스레드 구현을 얻게 되므로 R 수준에서 코드를 병렬화할 필요가 없습니다.
• 패키지 RCPP C++에 대한 진지한 지식 없이도 사용할 수 있으며 필요한 최소 수준이 설명되어 있습니다. 여기에. 다음과 같은 여러 가지 멋진 C 라이브러리에 대한 헤더 파일 엑스텐서 즉, 이미 만들어진 고성능 C++ 코드를 R에 통합하는 프로젝트 구현을 위한 인프라가 형성되고 있는 것입니다. 추가적인 편의성은 RStudio의 구문 강조 표시 및 정적 C++ 코드 분석기입니다.
• 도콥 매개변수를 사용하여 자체 포함된 스크립트를 실행할 수 있습니다. 이는 원격 서버에서 사용하기에 편리합니다. 도커 아래. RStudio에서는 신경망 훈련으로 많은 시간의 실험을 수행하는 것이 불편하고, 서버 자체에 IDE를 설치하는 것이 항상 정당화되는 것은 아닙니다.
• Docker는 서로 다른 버전의 OS 및 라이브러리를 사용하는 개발자 간의 코드 이식성과 결과 재현성을 보장할 뿐만 아니라 서버에서의 실행 용이성을 보장합니다. 단 하나의 명령으로 전체 학습 파이프라인을 시작할 수 있습니다.
• Google Cloud는 고가의 하드웨어를 실험할 수 있는 예산 친화적인 방법이지만 구성을 신중하게 선택해야 합니다.
• 개별 코드 조각의 속도를 측정하는 것은 특히 R과 C++를 결합하고 패키지와 함께 사용할 때 매우 유용합니다. 벤치 - 또한 매우 쉽습니다.

전반적으로 이번 경험은 매우 보람있는 일이었으며 제기된 문제 중 일부를 해결하기 위해 계속해서 노력하고 있습니다.

출처 : habr.com