Quick Draw Doodle Recognition: R、C++、ニューラル ネットワークと友達になる方法

おい、ハブル！

昨年の秋、Kaggle は手描きの絵を分類するコンテスト「Quick Draw Doodle Recognition」を主催しました。それには、とりわけ R 科学者のチームが参加しました。 アルテム・クレフツォワ, フィリパマネージャー и アンドレイ・オグルツォフ。 コンテストについては詳しく説明しません。すでに行われています。 最近の出版物.

今回はメダルファームではうまくいきませんでしたが、多くの貴重な経験が得られたので、Kagle や日常業務で最も興味深く役立つことの数々をコミュニティに伝えていきたいと思います。 議論されたトピックの中には、次のものが含まれます： OpenCV、JSON 解析 (これらの例では、R のスクリプトまたはパッケージへの C++ コードの統合を調べます。 ＲＣＰＰ)、スクリプトのパラメータ化、最終ソリューションの Docker 化。 実行に適した形式のメッセージのすべてのコードは、次の場所にあります。 リポジトリ.

内容：

1. CSV から MonetDB にデータを効率的にロードする
2. バッチの準備
3. データベースからバッチをアンロードするためのイテレータ
4. モデル アーキテクチャの選択
5. スクリプトのパラメータ化
6. スクリプトの Docker 化
7. Google Cloud での複数の GPU の使用
8. 代わりに、結論の

1. CSV から MonetDB データベースにデータを効率的にロードする

本コンテストのデータは既製の画像形式ではなく、点座標を含むJSONを含むCSVファイル340個（クラスごとに256ファイル）の形式で提供されます。 これらの点を線で結ぶと、256x7.4 ピクセルの最終画像が得られます。 また、各レコードには、データセットの収集時に使用された分類子によって画像が正しく認識されたかどうかを示すラベル、画像の作成者の居住国の 20 文字コード、一意の識別子、タイムスタンプが含まれます。ファイル名と一致するクラス名。 元のデータの簡易バージョンの重さはアーカイブ内で 240 GB、解凍後は約 50 GB、解凍後の完全なデータは XNUMX GB になります。 主催者は両方のバージョンで同じ図面を再現することを保証しました。これは、完全版が冗長であることを意味します。 いずれにせよ、XNUMX 万枚の画像をグラフィック ファイルまたは配列形式で保存するのは採算が合わないと判断され、アーカイブからすべての CSV ファイルを結合することにしました。 train_simplified.zip データベースに保存され、その後、バッチごとに必要なサイズの画像が「その場で」生成されます。

DBMS として実績のあるシステムが選択されました モネDB、つまりパッケージとしての R の実装 モネDBLite。 このパッケージにはデータベース サーバーの組み込みバージョンが含まれており、R セッションからサーバーを直接選択してそこで作業できるようになります。 データベースの作成とデータベースへの接続は、次の XNUMX つのコマンドで実行されます。

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

XNUMX つのテーブルを作成する必要があります。XNUMX つはすべてのデータ用で、もう XNUMX つはダウンロードされたファイルに関するサービス情報用です (何か問題が発生し、いくつかのファイルをダウンロードした後にプロセスを再開する必要がある場合に役立ちます)。

テーブルの作成

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

データのロード時間は、使用するドライブの速度特性によって異なる場合があります。 私たちの場合、10 つの SSD 内での読み取りと書き込み、またはフラッシュ ドライブ (ソース ファイル) から SSD (DB) への読み取りと書き込みには XNUMX 分もかかりません。

整数クラス ラベルとインデックス列 (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 つのトリックを使用しました。 XNUMX つ目は、観測 ID を格納する型の次元を削減することでした。 元のデータセットでは、ID を保存するために必要な型は次のとおりです。 bigintただし、観測値の数により、序数に等しい識別子を型に当てはめることができます。 int。 この場合、検索ははるかに高速になります。 XNUMX番目のトリックは使用することでした ORDERED INDEX — 私たちは利用可能なすべてのことを検討した結果、経験的にこの決定に達しました オプション。 XNUMX つ目は、パラメータ化されたクエリを使用することでした。 このメソッドの本質はコマンドを XNUMX 回実行することです PREPARE その後、同じタイプのクエリを多数作成するときに準備された式を使用しますが、実際には、単純なクエリと比較して利点があります。 SELECT 統計誤差の範囲内であることが判明しました。

データのアップロードのプロセスで消費される RAM は 450 MB 以内です。 つまり、ここで説明したアプローチを使用すると、シングルボード デバイスを含むほとんどすべての予算のハードウェア上で数十ギガバイトのデータセットを移動できるようになり、これは非常に優れています。

残っているのは、(ランダム) データの取得速度を測定し、さまざまなサイズのバッチをサンプリングするときのスケーリングを評価することだけです。

データベースベンチマーク

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 の最も単純かつ明白な類似物の XNUMX つは次のようになります。

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 用の既製のパッケージはありませんでした (現在はありません)。そのため、必要な機能の最小限の実装は C++ で記述され、以下を使用して R コードに統合されました。 ＲＣＰＰ.

この問題を解決するために、次のパッケージとライブラリが使用されました。

1. OpenCV 画像の操作や線の描画に使用します。 プリインストールされたシステム ライブラリとヘッダー ファイル、およびダイナミック リンクを使用しました。

2. エクステンソル 多次元配列とテンソルを操作するためのものです。 同じ名前の R パッケージに含まれるヘッダー ファイルを使用しました。 このライブラリを使用すると、行優先順序と列優先順序の両方で多次元配列を操作できます。

3. ンジソン JSON を解析するため。 このライブラリは以下で使用されます エクステンソル プロジェクト内に存在する場合は自動的に実行されます。

4. Rcppスレッド JSON からのベクトルのマルチスレッド処理を組織化します。 このパッケージで提供されるヘッダー ファイルを使用しました。 より人気のあるものから RcppParallel このパッケージには、とりわけループ割り込みメカニズムが組み込まれています。

これは、ことは注目に値します エクステンソル それは天の恵みでした。広範な機能と高いパフォーマンスを備えていることに加えて、開発者は非常に反応が良く、質問に迅速かつ詳細に答えてくれました。 彼らの助けにより、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

システム ファイルを使用するファイルと、システムにインストールされているライブラリとの動的リンクをコンパイルするには、パッケージに実装されているプラ​​グイン メカニズムを使用しました。 ＲＣＰＰ。 パスとフラグを自動的に検索するために、一般的な 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 ライブラリのすべての機能を利用できます。 keras 同じ名前のパッケージを使用するさまざまなバックエンドで、パッケージの上で動作します。 網状。 後者については、別の長い記事を書く価値があります。 R から Python コードを実行できるだけでなく、R と Python セッション間でオブジェクトを転送し、必要な型変換をすべて自動的に実行することもできます。

MonetDBLite を使用することで、すべてのデータを RAM に保存する必要がなくなりました。すべての「ニューラル ネットワーク」作業は Python の元のコードによって実行されます。何も準備ができていないため、データにイテレータを記述するだけで済みます。このような状況には、R または Python を使用します。 基本的に、その要件は XNUMX つだけです。無限ループでバッチを返すことと、反復間でその状態を保存することです (R における後者は、クロージャを使用する最も単純な方法で実装されます)。 以前は、イテレータ内で R 配列を numpy 配列に明示的に変換する必要がありましたが、現在のバージョンのパッケージでは keras 自分でやるのです。

トレーニング データと検証データのイテレータは次のようになりました。

トレーニングおよび検証データのイテレータ

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

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

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

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

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

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

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

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

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

この関数は、データベースへの接続、使用される行数、クラス数、バッチ サイズ、スケール (scale = 1 256x256 ピクセルのレンダリング画像に対応し、 scale = 0.5 — 128x128 ピクセル)、カラーインジケーター (color = FALSE 使用時にグレースケールでのレンダリングを指定します color = TRUE 各ストロークは新しい色で描画されます) と、imagenet で事前トレーニングされたネットワークの前処理インジケーターです。 後者は、ピクセル値を間隔 [0, 1] から間隔 [-1, 1] にスケーリングするために必要です。これは、提供されたトレーニング時に使用されました。 keras モデル。

外部関数には引数の型チェック、テーブルが含まれています。 data.table ランダムに混合された行番号 samples_index バッチ番号、カウンタ、バッチの最大数、およびデータベースからデータをアンロードするための SQL 式。 さらに、関数の高速な類似物を内部に定義しました。 keras::to_categorical()。 ほぼすべてのデータをトレーニングに使用し、半分のデータを検証用に残したため、エポック サイズはパラメータによって制限されました。 steps_per_epoch 呼ばれたとき keras::fit_generator()、および条件 if (i > max_i) 検証イテレータでのみ機能しました。

内部関数では、次のバッチの行インデックスが取得され、バッチ カウンターが増加してレコードがデータベースからアンロードされ、JSON 解析 (関数 cpp_process_json_vector()、C++ で書かれています）、画像に対応する配列を作成します。 次に、クラス ラベルを持つワンホット ベクトルが作成され、ピクセル値とラベルを持つ配列が戻り値のリストに結合されます。 作業を高速化するために、テーブル内にインデックスを作成しました。 data.table およびリンク経由の変更 - これらのパッケージ「チップ」なし データ表 R で大量のデータを効果的に処理することを想像するのは非常に困難です。

Core i5 ラップトップでの速度測定の結果は次のとおりです。

イテレータのベンチマーク

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

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

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

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

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

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

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

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

DBI::dbDisconnect(con, shutdown = TRUE)

十分な量の RAM がある場合は、データベースを同じ RAM に転送することで、データベースの動作を大幅に高速化できます (このタスクには 32 GB で十分です)。 Linux では、パーティションはデフォルトでマウントされます /dev/shm、RAM容量の最大半分を占有します。 編集することでさらに強調表示できます /etc/fstabのようなレコードを取得するには tmpfs /dev/shm tmpfs defaults,size=25g 0 0。 必ず再起動し、コマンドを実行して結果を確認してください。 df -h.

テスト データセットは完全に RAM に収まるため、テスト データのイテレータは非常に単純に見えます。

テストデータのイテレータ

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

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

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

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

4. モデルアーキテクチャの選択

最初に使用されたアーキテクチャは モバイルネット v1の機能については、 これ メッセージ。 標準で付属しています keras したがって、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)

これで、提供された関数のいずれかを取得するユニバーサル関数を作成するのは難しくなくなりました。 keras imagenet でトレーニングされた重みの有無にかかわらずモデル:

既製のアーキテクチャをロードする機能

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

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

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

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

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

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

  return(model)
}

シングルチャネル画像を使用する場合、事前トレーニングされた重みは使用されません。 これは修正できる可能性があります: 関数を使用する get_weights() R 配列のリストの形式でモデルの重みを取得し、このリストの最初の要素の次元を変更し (XNUMX つのカラー チャネルを取得するか、XNUMX つすべてを平均することによって)、関数を使用して重みをモデルにロードし直します。 set_weights()。 この段階では、カラー画像を処理する方が生産性が高いことがすでに明らかであったため、この機能は追加されませんでした。

ほとんどの実験は、mobilenet バージョン 1 と 2、および resnet34 を使用して実行しました。 SE-ResNeXt などの最新のアーキテクチャがこの競争で好成績を収めました。 残念ながら、自由に使える既製の実装がなく、独自の実装を作成しませんでした (ただし、必ず作成します)。

5. スクリプトのパラメータ化

便宜上、トレーニングを開始するためのすべてのコードは、次を使用してパラメータ化された単一のスクリプトとして設計されました。 ドックプト 次のようにします。

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

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

パッケージ ドックプト 実装を表します http://docopt.org/ R の場合、その助けを借りて、スクリプトは次のような単純なコマンドで起動されます。 Rscript bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db または ./bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db、ファイルの場合 train_nn.R 実行可能です (このコマンドはモデルのトレーニングを開始します) resnet50 128x128 ピクセルの XNUMX 色画像の場合、データベースは次のフォルダーに配置する必要があります。 /home/andrey/doodle_db）。 学習速度、オプティマイザーのタイプ、その他のカスタマイズ可能なパラメーターをリストに追加できます。 出版物の準備の過程で、アーキテクチャが次のとおりであることが判明しました。 mobilenet_v2 現在のバージョンから keras R使用中 してはいけません R パッケージでは変更が考慮されていないため、修正されるのを待っています。

このアプローチにより、RStudio でスクリプトを起動する従来の方法と比較して、さまざまなモデルでの実験を大幅に高速化することができました (代替手段としてパッケージに注目します) tfruns）。 ただし、主な利点は、RStudio をインストールしなくても、Docker または単にサーバー上でスクリプトの起動を簡単に管理できることです。

6. スクリプトの Docker 化

Docker を使用して、チーム メンバー間でモデルをトレーニングし、クラウドに迅速にデプロイするための環境の移植性を確保しました。 R プログラマーにとっては比較的珍しいこのツールについては、次の手順で始めることができます。 この シリーズの出版物や ビデオコース.

Docker を使用すると、独自のイメージを最初から作成することも、他のイメージを独自のイメージを作成するためのベースとして使用することもできます。 利用可能なオプションを分析したところ、NVIDIA、CUDA+cuDNN ドライバー、および Python ライブラリのインストールがイメージのかなりの部分であるという結論に達し、公式イメージを基礎として採用することにしました。 tensorflow/tensorflow:1.12.0-gpu、そこに必要な R パッケージを追加します。

最終的な docker ファイルは次のようになります。

ドッカーファイル

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 の使用

コンテストの特徴の 1 つは、非常にノイズの多いデータでした (ODS スラックの @Leigh.plt から借用したタイトル画像を参照)。 大規模なバッチはこれに対処するのに役立ちます。XNUMX 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. 結論ではなく

私たちが遭遇した多くの問題はまだ克服されていません。

• в keras 最適な学習率を自動的に検索する既製の機能はありません（アナログ） lr_finder 図書館で 高速.ai); ある程度の努力をすれば、サードパーティの実装を R に移植することができます。たとえば、次のようになります。 この;
• 前の点の結果として、複数の GPU を使用する場合、正しいトレーニング速度を選択することができませんでした。
• 最新のニューラル ネットワーク アーキテクチャ、特に imagenet で事前トレーニングされたものが不足しています。
• XNUMX サイクル ポリシーと識別学習率はありません (コサイン アニーリングは私たちの要望に応じて行われました) 実装された、ありがとうございました スカイダン).

このコンテストから学んだ有益なことは次のとおりです。

• 比較的低電力のハードウェアでは、まともな (RAM の何倍ものサイズの) ボリュームのデータを苦痛なく処理できます。 ビニール袋 データ表 テーブルのインプレース変更によりメモリが節約され、テーブルのコピーが回避されます。また、正しく使用すると、その機能はほとんどの場合、スクリプト言語用として知られているすべてのツールの中で最高の速度を示します。 データをデータベースに保存すると、多くの場合、データセット全体を RAM に詰め込む必要性についてまったく考える必要がなくなります。
• R の遅い関数は、パッケージを使用して C++ の速い関数に置き換えることができます ＲＣＰＰ。 さらに使用する場合 Rcppスレッド または RcppParallel、クロスプラットフォームのマルチスレッド実装が得られるため、R レベルでコードを並列化する必要はありません。
• パッケージ別 ＲＣＰＰ C++ の深い知識がなくても使用できますが、最低限必要なものが概説されています ここで。 次のような多くの優れた C ライブラリのヘッダー ファイル エクステンソル つまり、既製の高性能 C++ コードを R に統合するプロジェクトの実装のためのインフラストラクチャが形成されています。 さらに便利なのは、RStudio の構文ハイライトと静的 C++ コード アナライザーです。
• ドックプト パラメーターを使用して自己完結型スクリプトを実行できます。 これは、リモート サーバーで使用する場合に便利です。 ドッカーの下。 RStudio では、ニューラル ネットワークをトレーニングするための何時間もの実験を行うのは不便であり、サーバー自体に IDE をインストールすることが必ずしも正当であるとは限りません。
• Docker は、異なるバージョンの OS やライブラリを使用する開発者間でのコードの移植性と結果の再現性、およびサーバーでの実行の容易さを保証します。 たった XNUMX つのコマンドでトレーニング パイプライン全体を起動できます。
• Google Cloud は、高価なハードウェアを試すための予算に優しい方法ですが、構成を慎重に選択する必要があります。
• 個々のコードフラグメントの速度を測定することは、特に R と C++ を組み合わせたり、パッケージと組み合わせたりする場合に非常に役立ちます。 ベンチ - これも非常に簡単です。

全体として、この経験は非常に価値のあるものであり、私たちは提起された問題のいくつかを解決するために引き続き取り組んでいます。

出所： habr.com