嘿哈布尔！
去年秋天，Kaggle 举办了一场手绘图片分类竞赛 Quick Draw Doodle Recognition，其中包括一组 R 科学家参加的竞赛： , и 。 我们不会详细描述比赛；这已经在 .
这次刷奖牌虽然没有成功，但是获得了很多宝贵的经验，所以我想向社区介绍一些 Kagle 上以及日常工作中最有趣、最有用的东西。 讨论的主题包括：没有的困难生活 OpenCV的、JSON 解析（这些示例检查 C++ 代码与 R 中的脚本或包的集成，使用 反倾销）、脚本参数化和最终解决方案的 Docker 化。 消息中的所有代码均以适合执行的形式提供 .
内容：
1.高效地将数据从CSV加载到MonetDB数据库中
本次比赛的数据不是以现成图像的形式提供，而是以 340 个 CSV 文件（每个类别一个文件）的形式提供，其中包含带有点坐标的 JSON。 通过用线连接这些点，我们得到了 256x256 像素的最终图像。 此外，对于每条记录，还有一个标签，指示收集数据集时使用的分类器是否正确识别图片、图片作者居住国家/地区的两个字母代码、唯一标识符、时间戳以及与文件名匹配的类名。 原始数据的简化版本在压缩包中重7.4GB，解压后约20GB，解压后的完整数据占用240GB。 组织者确保两个版本都复制相同的图纸，这意味着完整版本是多余的。 无论如何，以图形文件或数组的形式存储 50 万张图像立即被认为是无利可图的，因此我们决定合并存档中的所有 CSV 文件 train_simplified.zip 进入数据库，随后为每批“即时”生成所需尺寸的图像。
选择一个经过充分验证的系统作为 DBMS 数据库，即 R 作为包的实现 。 该软件包包含数据库服务器的嵌入式版本，允许您直接从 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 结果显示在统计误差范围内。
上传数据的过程消耗不超过450 MB RAM。 也就是说，所描述的方法允许您在几乎任何预算硬件（包括一些单板设备）上移动数十 GB 的数据集，这非常酷。
剩下的就是测量检索（随机）数据的速度并评估对不同大小的批次进行采样时的缩放比例：
数据库基准测试
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. 准备批次
整个批次制备过程包括以下步骤：
- 解析多个包含带有点坐标的字符串向量的 JSON。
- 根据所需尺寸（例如256×256或128×128）的图像上的点坐标绘制彩色线条。
- 将生成的图像转换为张量。
作为Python内核之间竞争的一部分，该问题主要通过使用 OpenCV的。 R 中最简单、最明显的类似物之一如下所示：
在 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 工具执行绘图，并将其保存到存储在 RAM 中的临时 PNG（在 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 代码中 反倾销.
为了解决该问题，使用了以下包和库：
-
OpenCV的 用于处理图像和绘制线条。 使用预装的系统库和头文件，以及动态链接。
-
x张量 用于处理多维数组和张量。 我们使用同名 R 包中包含的头文件。 该库允许您使用多维数组，无论是行主顺序还是列主顺序。
-
ndjson 用于解析 JSON。 该库用于 x张量 如果项目中存在，则自动进行。
-
Rcpp线程 用于组织 JSON 向量的多线程处理。 使用了这个包提供的头文件。 来自比较热门的 Rcpp并行 除其他外，该软件包还具有内置的循环中断机制。
值得一提的是 x张量 事实证明这是天赐之物：除了具有广泛的功能和高性能之外，其开发人员的反应也非常灵敏，并迅速而详细地回答了问题。 在他们的帮助下，可以实现 OpenCV 矩阵到 xtensor 张量的转换，以及将 3 维图像张量组合成正确维度（批次本身）的 4 维张量的方法。
学习 Rcpp、xtensor 和 RcppThread 的材料
为了编译使用系统文件并动态链接系统上安装的库的文件，我们使用了包中实现的插件机制 反倾销。 为了自动查找路径和标志，我们使用了流行的 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++ 编写）并创建与图片对应的数组。 然后创建带有类标签的one-hot向量，将带有像素值和标签的数组组合成一个列表，这就是返回值。 为了加快工作速度，我们在表中创建索引 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.模型架构的选择
第一个使用的架构是 ，其特征在中讨论 信息。 它是标准配置 凯拉斯 并且，相应地，可以在 R 的同名包中使用。但是当尝试将其与单通道图像一起使用时，出现了奇怪的事情：输入张量必须始终具有维度 (batch, height, width, 3)，即通道数不能改变。 Python 中没有这样的限制，因此我们按照原始文章（没有 keras 版本中的 dropout），匆忙编写了该架构的自己的实现：
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()。 我们从未添加此功能，因为在现阶段已经很明显，处理彩色图片的效率更高。
我们使用 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)包 医生 代表实施 在 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中使用 由于 R 包中未考虑到更改，我们正在等待他们修复它。
与 RStudio 中更传统的脚本启动相比，这种方法可以显着加快不同模型的实验速度（我们注意到该包是一种可能的替代方案） ）。 但主要优点是能够轻松管理 Docker 中或仅在服务器上启动脚本，而无需为此安装 RStudio。
6. 脚本的 Docker 化
我们使用 Docker 来确保团队成员之间训练模型环境的可移植性以及在云中的快速部署。 您可以开始熟悉这个工具，这对于 R 程序员来说相对不常见，方法是： 系列出版物或 .
Docker 允许您从头开始创建自己的映像，并使用其他映像作为创建自己的映像的基础。 在分析可用选项时，我们得出的结论是，安装 NVIDIA、CUDA+cuDNN 驱动程序和 Python 库是镜像中相当多的部分，因此我们决定以官方镜像为基础 tensorflow/tensorflow:1.12.0-gpu，在那里添加必要的 R 包。
最终的 docker 文件如下所示：
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
为了方便，使用的包被放入变量中； 大部分编写的脚本在组装期间被复制到容器内。 我们还将命令 shell 更改为 /bin/bash 为了便于使用内容 /etc/os-release。 这避免了在代码中指定操作系统版本的需要。
此外，还编写了一个小型 bash 脚本，允许您使用各种命令启动容器。 例如，这些可以是之前放置在容器内的用于训练神经网络的脚本，或者是用于调试和监视容器操作的命令 shell：
启动容器的脚本
#!/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”，那么容器将与命令 shell 交互启动。 在所有其他情况下，位置参数的值都会被替换： 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 的代码片段。 首先，模型是使用上下文管理器在 CPU 上创建的，就像在 Python 中一样：
with(tensorflow::tf$device("/cpu:0"), {
model_cpu <- get_model(
name = model_name,
input_shape = input_shape,
weights = weights,
metrics =(top_3_categorical_accuracy,
compile = FALSE
)
})然后将未编译的（这很重要）模型复制到给定数量的可用 GPU，只有在此之后才对其进行编译：
model <- keras::multi_gpu_model(model_cpu, gpus = n_gpu)
keras::compile(
object = model,
optimizer = keras::optimizer_adam(lr = 0.0004),
loss = "categorical_crossentropy",
metrics = c(top_3_categorical_accuracy)
)冻结除最后一层之外的所有层、训练最后一层、解冻并为多个 GPU 重新训练整个模型的经典技术无法实现。
训练是在没有使用的情况下进行监测的。 张量板，限制我们在每个纪元之后记录日志并使用信息丰富的名称保存模型：
回调
# Шаблон имени файла лога
log_file_tmpl <- file.path("logs", sprintf(
"%s_%d_%dch_%s.csv",
model_name,
dim_size,
channels,
format(Sys.time(), "%Y%m%d%H%M%OS")
))
# Шаблон имени файла модели
model_file_tmpl <- file.path("models", sprintf(
"%s_%d_%dch_{epoch:02d}_{val_loss:.2f}.h5",
model_name,
dim_size,
channels
))
callbacks_list <- list(
keras::callback_csv_logger(
filename = log_file_tmpl
),
keras::callback_early_stopping(
monitor = "val_loss",
min_delta = 1e-4,
patience = 8,
verbose = 1,
mode = "min"
),
keras::callback_reduce_lr_on_plateau(
monitor = "val_loss",
factor = 0.5, # уменьшаем lr в 2 раза
patience = 4,
verbose = 1,
min_delta = 1e-4,
mode = "min"
),
keras::callback_model_checkpoint(
filepath = model_file_tmpl,
monitor = "val_loss",
save_best_only = FALSE,
save_weights_only = FALSE,
mode = "min"
)
)8. 代替结论
我们遇到的一些问题尚未得到解决：
- в 凯拉斯 没有现成的自动搜索最佳学习率的函数（模拟
lr_finder在图书馆里 快）； 经过一些努力，可以将第三方实现移植到 R，例如， ; - 由于上一点的原因，在使用多个 GPU 时无法选择正确的训练速度；
- 缺乏现代神经网络架构，尤其是在 imagenet 上预训练的神经网络架构；
- 没有一个循环政策和歧视性学习率（余弦退火是应我们的要求 谢谢 ).
从这次比赛中学到了哪些有用的东西：
- 在功耗相对较低的硬件上，您可以轻松处理大量（RAM 大小的许多倍）数据量。 塑料袋 数据表 由于表的就地修改而节省了内存，从而避免了复制它们，并且如果正确使用，它的功能几乎总是表现出我们已知的所有脚本语言工具中的最高速度。 在许多情况下，将数据保存在数据库中可以让您根本不需要考虑将整个数据集压缩到 RAM 中的必要性。
- R 中的慢速函数可以使用 C++ 中的快速函数替换 反倾销。 如果除了使用 Rcpp线程 или Rcpp并行，我们得到了跨平台的多线程实现，因此不需要在R级别并行化代码。
- 按包装 反倾销 无需深入了解 C++ 即可使用，概述了所需的最低要求 。 许多很酷的 C 库的头文件，例如 x张量 CRAN 上可用，也就是说，正在形成一个基础设施，用于实施将现成的高性能 C++ 代码集成到 R 中的项目。 额外的便利是 RStudio 中的语法突出显示和静态 C++ 代码分析器。
- 医生 允许您运行带参数的独立脚本。 这对于在远程服务器上使用很方便，包括。 在码头工人下。 在 RStudio 中，进行多个小时的实验来训练神经网络并不方便，并且在服务器本身上安装 IDE 并不总是合理的。
- Docker 确保了具有不同版本操作系统和库的开发人员之间的代码可移植性和结果的可重复性，以及在服务器上的易于执行性。 您只需一个命令即可启动整个训练管道。
- Google Cloud 是一种在昂贵的硬件上进行实验的经济实惠的方式，但您需要仔细选择配置。
- 测量单个代码片段的速度非常有用，尤其是在结合 R 和 C++ 以及使用包时 长凳 - 也很容易。
总的来说，这次经历非常有价值，我们将继续努力解决提出的一些问题。
来源： habr.com