හෙලෝ, හබ්ර්!
පසුගිය සරත් සෘතුවේ දී, Kaggle අතින් අඳින ලද පින්තූර, Quick Draw Doodle Recognition වර්ගීකරණය කිරීම සඳහා තරඟයක් පවත්වන ලදී, අනෙක් අතර, R-විද්යාඥයින් කණ්ඩායමක් සහභාගී විය: , и . අපි තරඟය විස්තරාත්මකව විස්තර නොකරමු; එය දැනටමත් සිදු කර ඇත .
මෙවර එය පදක්කම් ගොවිතැන සමඟ සාර්ථක නොවූ නමුත් වටිනා අත්දැකීම් රාශියක් ලබා ගත් බැවින් Kagle හි සහ එදිනෙදා වැඩවලදී වඩාත් රසවත් හා ප්රයෝජනවත් කරුණු ගණනාවක් පිළිබඳව මම ප්‍රජාවට පැවසීමට කැමැත්තෙමි. සාකච්ඡා කළ මාතෘකා අතර: දුෂ්කර ජීවිතයක් නොමැතිව OpenCV, JSON විග්‍රහ කිරීම (මෙම උදාහරණ මගින් C++ කේතය ස්ක්‍රිප්ට් හෝ පැකේජ තුලට R භාවිතා කර ඒකාබද්ධ කිරීම පරීක්ෂා කරයි. Rcpp), ස්ක්‍රිප්ට් පරාමිතිකරණය සහ අවසාන විසඳුමේ ඩොකරීකරණය. ක්රියාත්මක කිරීමට සුදුසු පෝරමයකින් පණිවිඩයේ ඇති සියලුම කේතයන් ලබා ගත හැක .
Содержание:
1. CSV වෙතින් MonetDB දත්ත ගබඩාවට කාර්යක්ෂමව දත්ත පූරණය කරන්න
මෙම තරඟයේ දත්ත සපයනු ලබන්නේ සූදානම් කළ රූප ආකාරයෙන් නොව, ලක්ෂ්ය ඛණ්ඩාංක සහිත JSON අඩංගු CSV ගොනු 340 (එක් එක් පන්තිය සඳහා එක් ගොනුවක්) ආකාරයෙන්ය. මෙම ලක්ෂ්ය රේඛා සමඟ සම්බන්ධ කිරීමෙන්, අපට පික්සල 256x256 ප්‍රමාණයේ අවසාන රූපයක් ලැබේ. එක් එක් වාර්තාව සඳහා දත්ත කට්ටලය එකතු කරන අවස්ථාවේ භාවිතා කරන ලද වර්ගීකාරකය විසින් පින්තූරය නිවැරදිව හඳුනාගෙන තිබේද යන්න දැක්වෙන ලේබලයක් ඇත, පින්තූරයේ කතුවරයාගේ පදිංචි රටෙහි අකුරු දෙකක කේතයක්, අද්විතීය හඳුනාගැනීමක්, වේලා මුද්රාවක් සහ ගොනු නාමයට ගැලපෙන පන්ති නාමයක්. මුල් දත්තවල සරල කළ අනුවාදයක් ලේඛනාගාරයේ 7.4 GB බරින් යුක්ත වන අතර අසුරන ලද පසු දළ වශයෙන් 20 GB පමණ වන අතර, ඉවත් කිරීමෙන් පසු සම්පූර්ණ දත්ත 240 GB පමණ වේ. අනුවාද දෙකම එකම චිත්‍ර ප්‍රතිනිෂ්පාදනය කරන බවට සංවිධායකයින් සහතික විය, එනම් සම්පූර්ණ අනුවාදය අතිරික්ත බවයි. ඕනෑම අවස්ථාවක, රූප මිලියන 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 ක් භාවිතා කළා. පළමුවැන්න නම් නිරීක්ෂණ හැඳුනුම්පත ගබඩා කරන ආකාරයේ මානයන් අඩු කිරීමයි. මුල් දත්ත කට්ටලයේ, හැඳුනුම්පත ගබඩා කිරීමට අවශ්ය වර්ගය වේ bigint, නමුත් නිරීක්ෂණ ගණන අනුව ඒවායේ හඳුනාගැනීම්, සාමාන්‍ය අංකයට සමාන, වර්ගයට ගැළපීමට හැකි වේ. int. මෙම නඩුවේ සෙවීම වඩා වේගවත් වේ. දෙවන උපක්රමය වූයේ භාවිතා කිරීමයි ORDERED INDEX - අපි මෙම තීරණයට පැමිණියේ ආනුභවිකව, පවතින සියල්ල හරහා ය . තෙවැන්න පරාමිතික විමසුම් භාවිතා කිරීමයි. ක්රමයේ සාරය නම් විධානය එක් වරක් ක්රියාත්මක කිරීමයි PREPARE එකම ආකාරයේ විමසුම් සමූහයක් නිර්මාණය කිරීමේදී සකස් කළ ප්‍රකාශනයක් පසුව භාවිතා කිරීමත් සමඟ, නමුත් ඇත්ත වශයෙන්ම සරල එකක් සමඟ සැසඳීමේ වාසියක් ඇත SELECT සංඛ්‍යානමය දෝෂ පරාසය තුළ ඇති බව පෙනී ගියේය.
දත්ත උඩුගත කිරීමේ ක්රියාවලිය 450 MB ට වඩා RAM ප්රමාණයක් පරිභෝජනය කරයි. එනම්, විස්තර කරන ලද ප්‍රවේශය මඟින් ඔබට ගිගාබයිට් දස දහස් ගණනක් බරින් යුත් දත්ත කට්ටල ගෙනයාමට ඉඩ සලසයි, සමහර තනි පුවරු උපාංග ඇතුළුව ඕනෑම අයවැය දෘඩාංගයක් මත එය ඉතා සිසිල් ය.
ඉතිරිව ඇත්තේ (අහඹු) දත්ත ලබා ගැනීමේ වේගය මැනීම සහ විවිධ ප්‍රමාණයේ කණ්ඩායම් නියැදීමේදී පරිමාණය තක්සේරු කිරීම පමණි:
දත්ත සමුදා මිණුම් ලකුණ
library(ggplot2)
set.seed(0)
# Подключение к базе данных
con <- DBI::dbConnect(MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))
# Функция для подготовки запроса на стороне сервера
prep_sql <- function(batch_size) {
sql <- sprintf("PREPARE SELECT id FROM doodles WHERE id IN (%s)",
paste(rep("?", batch_size), collapse = ","))
res <- DBI::dbSendQuery(con, sql)
return(res)
}
# Функция для извлечения данных
fetch_data <- function(rs, batch_size) {
ids <- sample(seq_len(n), batch_size)
res <- DBI::dbFetch(DBI::dbBind(rs, as.list(ids)))
return(res)
}
# Проведение замера
res_bench <- bench::press(
batch_size = 2^(4:10),
{
rs <- prep_sql(batch_size)
bench::mark(
fetch_data(rs, batch_size),
min_iterations = 50L
)
}
)
# Параметры бенчмарка
cols <- c("batch_size", "min", "median", "max", "itr/sec", "total_time", "n_itr")
res_bench[, cols]
# batch_size min median max `itr/sec` total_time n_itr
# <dbl> <bch:tm> <bch:tm> <bch:tm> <dbl> <bch:tm> <int>
# 1 16 23.6ms 54.02ms 93.43ms 18.8 2.6s 49
# 2 32 38ms 84.83ms 151.55ms 11.4 4.29s 49
# 3 64 63.3ms 175.54ms 248.94ms 5.85 8.54s 50
# 4 128 83.2ms 341.52ms 496.24ms 3.00 16.69s 50
# 5 256 232.8ms 653.21ms 847.44ms 1.58 31.66s 50
# 6 512 784.6ms 1.41s 1.98s 0.740 1.1m 49
# 7 1024 681.7ms 2.72s 4.06s 0.377 2.16m 49
ggplot(res_bench, aes(x = factor(batch_size), y = median, group = 1)) +
geom_point() +
geom_line() +
ylab("median time, s") +
theme_minimal()
DBI::dbDisconnect(con, shutdown = TRUE)
2. කණ්ඩායම් සකස් කිරීම
සම්පූර්ණ කණ්ඩායම සකස් කිරීමේ ක්රියාවලිය පහත පියවර වලින් සමන්විත වේ:
- ලක්ෂ්ය ඛණ්ඩාංක සහිත නූල් දෛශික අඩංගු JSON කිහිපයක් විග්‍රහ කිරීම.
- අවශ්ය ප්‍රමාණයේ රූපයක් මත ලක්ෂ්ය ඛණ්ඩාංක මත පදනම්ව වර්ණ රේඛා ඇඳීම (උදාහරණයක් ලෙස, 256×256 හෝ 128×128).
- ලැබෙන රූප ටෙන්සරයක් බවට පරිවර්තනය කිරීම.
පයිතන් කර්නල් අතර තරඟයේ කොටසක් ලෙස, ගැටළුව මූලික වශයෙන් භාවිතා කර විසඳා ඇත 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 වෙත සුරකිනු ලැබේ (ලිනක්ස් හි, තාවකාලික R නාමාවලි නාමාවලියෙහි පිහිටා ඇත. /tmp, RAM හි සවි කර ඇත). මෙම ගොනුව පසුව 0 සිට 1 දක්වා වූ සංඛ්‍යා සහිත ත්‍රිමාන අරාවක් ලෙස කියවනු ලැබේ. මෙය වැදගත් වන්නේ වඩාත් සාම්ප්‍රදායික BMP හෙක්ස් වර්ණ කේත සහිත අමු අරාවකට කියවන බැවිනි.
අපි ප්රතිඵලය පරීක්ෂා කරමු:
zip_file <- file.path("data", "train_simplified.zip")
csv_file <- "cat.csv"
unzip(zip_file, files = csv_file, exdir = tempdir(),
junkpaths = TRUE, unzip = getOption("unzip"))
tmp_data <- data.table::fread(file.path(tempdir(), csv_file), sep = ",",
select = "drawing", nrows = 10000)
arr <- r_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256 3
plot(magick::image_read(arr))
කණ්ඩායමම පහත පරිදි සාදනු ලැබේ:
res <- r_process_json_vector(tmp_data[1:4, drawing], scale = 0.5)
str(res)
# num [1:4, 1:128, 1:128, 1:3] 1 1 1 1 1 1 1 1 1 1 ...
# - attr(*, "dimnames")=List of 4
# ..$ : NULL
# ..$ : NULL
# ..$ : NULL
# ..$ : NULLවිශාල කණ්ඩායම් සෑදීමට අශෝභන ලෙස දිගු කාලයක් ගත වන බැවින් මෙම ක්රියාත්මක කිරීම අපට ප්‍රශස්ත ලෙස පෙනුණි, සහ ප්‍රබල පුස්තකාලයක් භාවිතා කරමින් අපගේ සගයන්ගේ අත්දැකීම් වලින් ප්‍රයෝජන ගැනීමට අපි තීරණය කළෙමු. OpenCV. එකල R සඳහා සූදානම් කළ පැකේජයක් නොතිබුණි (දැන් කිසිවක් නැත), එබැවින් අවශ්ය ක්‍රියාකාරීත්වයේ අවම ක්රියාත්මක කිරීමක් C++ හි ලියා ඇත්තේ R කේතයට ඒකාබද්ධ කිරීමෙනි. Rcpp.
ගැටළුව විසඳීම සඳහා, පහත පැකේජ සහ පුස්තකාල භාවිතා කරන ලදී:
-
OpenCV රූප සහ ඇඳීම් රේඛා සමඟ වැඩ කිරීම සඳහා. කලින් ස්ථාපනය කරන ලද පද්ධති පුස්තකාල සහ ශීර්ෂ ගොනු මෙන්ම ගතික සම්බන්ධ කිරීම භාවිතා කරන ලදී.
-
xtensor බහුමාන අරා සහ ටෙන්සර් සමඟ වැඩ කිරීම සඳහා. අපි එකම නමින් R පැකේජයේ ඇතුළත් ශීර්ෂ ගොනු භාවිතා කළෙමු. පුස්තකාලය ඔබට බහුමාන අරා සමඟ වැඩ කිරීමට ඉඩ සලසයි, පේළියේ ප්‍රධාන සහ තීරු ප්‍රධාන අනුපිළිවෙලෙහි.
-
ndjson JSON විග්‍රහ කිරීම සඳහා. මෙම පුස්තකාලය භාවිතා වේ xtensor එය ව්‍යාපෘතියේ තිබේ නම් ස්වයංක්‍රීයව.
-
RcppThread JSON වෙතින් දෛශිකයක බහු-නූල් සැකසුම් සංවිධානය කිරීම සඳහා. මෙම පැකේජය මඟින් සපයන ලද ශීර්ෂ ගොනු භාවිතා කරන ලදී. වඩාත් ජනප්රිය සිට RcppParallel පැකේජය, වෙනත් දේ අතර, ලූප බාධා කිරීමේ යාන්ත්‍රණයක් ඇත.
එය සඳහන් කිරීම වටී xtensor දේව වරප්‍රසාදයක් බවට පත් විය: එහි පුළුල් ක්‍රියාකාරීත්වයක් සහ ඉහළ ක්‍රියාකාරීත්වයක් ඇති බවට අමතරව, එහි සංවර්ධකයින් තරමක් ප්‍රතිචාර දක්වන අතර ප්‍රශ්නවලට ක්ෂණිකව සහ විස්තරාත්මකව පිළිතුරු දුන්හ. ඔවුන්ගේ සහය ඇතිව, OpenCV matrices xtensor ටෙන්සර් බවට පරිවර්තනය කිරීම ක්රියාත්මක කිරීමට මෙන්ම 3-මාන රූප ටෙන්සර් නිවැරදි මානයෙහි 4-මාන ආතන්යයකට ඒකාබද්ධ කිරීමේ ක්‍රමයක් (කාණ්ඩයම) ක්රියාත්මක කිරීමට හැකි විය.
Rcpp, xtensor සහ RcppThread ඉගෙනීමට අවශ්ය ද්‍රව්‍ය
පද්ධති ගොනු භාවිතා කරන ගොනු සම්පාදනය කිරීම සහ පද්ධතියේ ස්ථාපනය කර ඇති පුස්තකාල සමඟ ගතික සම්බන්ධ කිරීම සඳහා, අපි පැකේජයේ ක්රියාත්මක කර ඇති ප්ලගින යාන්ත්‍රණය භාවිතා කළෙමු. Rcpp. මාර්ග සහ කොඩි ස්වයංක්‍රීයව සොයා ගැනීමට, අපි ජනප්රිය Linux උපයෝගීතාවයක් භාවිතා කළෙමු pkg-config.
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-object (බහුමාන අරාව) වෙත ප්රතිඵලය අපනයනය කරයි; -
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. දත්ත සමුදායෙන් කණ්ඩායම් බෑම සඳහා පුනරාවර්තක
RAM වලට ගැළපෙන දත්ත සැකසීම සඳහා R හට හොඳ නමක් ඇති අතර, Python පුනරාවර්තන දත්ත සැකසීමෙන් වඩාත් සංලක්ෂිත වන අතර, ඔබට පහසුවෙන් සහ ස්වභාවිකව හරයෙන් බැහැර ගණනය කිරීම් (බාහිර මතකය භාවිතයෙන් ගණනය කිරීම්) ක්රියාත්මක කිරීමට ඉඩ සලසයි. විස්තර කරන ලද ගැටලුවේ සන්දර්භය තුළ අපට සම්භාව්‍ය සහ අදාළ උදාහරණයක් වන්නේ නිරීක්ෂණවල කුඩා කොටසක් හෝ කුඩා කණ්ඩායමක් භාවිතා කරමින් සෑම පියවරකදීම අනුක්‍රමය ආසන්න කිරීම සමඟ අනුක්‍රමය බැසීමේ ක්‍රමය මගින් පුහුණු කරන ලද ගැඹුරු ස්නායුක ජාල ය.
Python හි ලියා ඇති ගැඹුරු ඉගෙනුම් රාමු වල දත්ත මත පදනම් වූ පුනරාවර්තක ක්රියාත්මක කරන විශේෂ පන්ති ඇත: වගු, ෆෝල්ඩරවල පින්තූර, ද්විමය ආකෘති, ආදිය. ඔබට නිශ්චිත කාර්යයන් සඳහා සූදානම් කළ විකල්ප භාවිතා කිරීමට හෝ ඔබේම ඒවා ලිවීමට හැකිය. R හි අපට පයිතන් පුස්තකාලයේ සියලුම විශේෂාංග වලින් ප්‍රයෝජන ගත හැකිය keras එහි විවිධ පසුබිම් සමඟ එකම නමේ පැකේජය භාවිතා කරයි, එය පැකේජයට ඉහළින් ක්රියා කරයි රෙටිකියුලේට්. දෙවැන්න වෙනම දිගු ලිපියක් ලැබිය යුතුය; එය ඔබට R වෙතින් Python කේතය ධාවනය කිරීමට පමණක් නොව, R සහ Python සැසි අතර වස්තු මාරු කිරීමට ඔබට ඉඩ සලසයි, අවශ්ය සියලුම ආකාරයේ පරිවර්තන ස්වයංක්‍රීයව සිදු කරයි.
MonetDBLite භාවිතා කිරීමෙන් සියලුම දත්ත RAM හි ගබඩා කිරීමේ අවශ්‍යතාවයෙන් අපි මිදුනෙමු, සියලුම “ස්නායු ජාල” වැඩ පයිතන් හි මුල් කේතයෙන් සිදු කෙරේ, අපට කිසිවක් සූදානම් නැති බැවින් දත්ත මත පුනරාවර්තකයක් ලිවිය යුතුය. R හෝ Python හි එවැනි තත්වයක් සඳහා. ඒ සඳහා අවශ්‍යයෙන්ම ඇත්තේ අවශ්‍යතා දෙකක් පමණි: එය නිමක් නැති ලූපයකින් කණ්ඩායම් ආපසු ලබා දිය යුතු අතර පුනරාවර්තන අතර එහි තත්වය සුරැකිය යුතුය (R හි දෙවැන්න වසා දැමීම් භාවිතයෙන් සරලම ආකාරයෙන් ක්රියාත්මක වේ). මීට පෙර, පුනරාවර්තකය තුළ R arrays numpy arrays බවට පැහැදිලිව පරිවර්තනය කිරීමට අවශ්ය විය, නමුත් පැකේජයේ වත්මන් අනුවාදය 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 ප්රමාණවත් වේ). ලිනක්ස් හි, කොටස පෙරනිමියෙන් සවි කර ඇත /dev/shm, RAM ධාරිතාවෙන් අඩක් දක්වා වාසය කරයි. සංස්කරණය කිරීමෙන් ඔබට තවත් ඉස්මතු කළ හැක /etc/fstabවැනි වාර්තාවක් ලබා ගැනීමට tmpfs /dev/shm tmpfs defaults,size=25g 0 0. විධානය ක්රියාත්මක කිරීමෙන් නැවත ආරම්භ කර ප්‍රති result ලය පරීක්ෂා කිරීමට වග බලා ගන්න 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. ආදර්ශ ගෘහ නිර්මාණ ශිල්පය තෝරා ගැනීම
මුලින්ම භාවිතා කරන ලද ගෘහ නිර්මාණ ශිල්පය විය , එහි ලක්ෂණ සාකච්ඡා කෙරේ පණිවුඩය. එය සම්මතයක් ලෙස ඇතුළත් කර ඇත keras සහ, ඒ අනුව, R සඳහා එකම නමේ පැකේජයේ ඇත. නමුත් එය තනි නාලිකා රූප සමඟ භාවිතා කිරීමට උත්සාහ කරන විට, අමුතු දෙයක් සිදු විය: ආදාන ටෙන්සරය සැමවිටම මානය තිබිය යුතුය. (batch, height, width, 3), එනම්, නාලිකා ගණන වෙනස් කළ නොහැක. Python හි එවැනි සීමාවක් නොමැත, එබැවින් අපි ඉක්මන් වී මෙම ගෘහ නිර්මාණ ශිල්පය ක්රියාත්මක කිරීම සඳහා මුල් ලිපිය අනුගමනය කරමින් (keras අනුවාදයේ ඇති අතහැරීමකින් තොරව) ලිව්වෙමු:
Mobilenet v1 ගෘහ නිර්මාණ ශිල්පය
library(keras)
top_3_categorical_accuracy <- custom_metric(
name = "top_3_categorical_accuracy",
metric_fn = function(y_true, y_pred) {
metric_top_k_categorical_accuracy(y_true, y_pred, k = 3)
}
)
layer_sep_conv_bn <- function(object,
filters,
alpha = 1,
depth_multiplier = 1,
strides = c(2, 2)) {
# NB! depth_multiplier != resolution multiplier
# https://github.com/keras-team/keras/issues/10349
layer_depthwise_conv_2d(
object = object,
kernel_size = c(3, 3),
strides = strides,
padding = "same",
depth_multiplier = depth_multiplier
) %>%
layer_batch_normalization() %>%
layer_activation_relu() %>%
layer_conv_2d(
filters = filters * alpha,
kernel_size = c(1, 1),
strides = c(1, 1)
) %>%
layer_batch_normalization() %>%
layer_activation_relu()
}
get_mobilenet_v1 <- function(input_shape = c(224, 224, 1),
num_classes = 340,
alpha = 1,
depth_multiplier = 1,
optimizer = optimizer_adam(lr = 0.002),
loss = "categorical_crossentropy",
metrics = c("categorical_crossentropy",
top_3_categorical_accuracy)) {
inputs <- layer_input(shape = input_shape)
outputs <- inputs %>%
layer_conv_2d(filters = 32, kernel_size = c(3, 3), strides = c(2, 2), padding = "same") %>%
layer_batch_normalization() %>%
layer_activation_relu() %>%
layer_sep_conv_bn(filters = 64, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 128, strides = c(2, 2)) %>%
layer_sep_conv_bn(filters = 128, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 256, strides = c(2, 2)) %>%
layer_sep_conv_bn(filters = 256, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 512, strides = c(2, 2)) %>%
layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
layer_sep_conv_bn(filters = 1024, strides = c(2, 2)) %>%
layer_sep_conv_bn(filters = 1024, strides = c(1, 1)) %>%
layer_global_average_pooling_2d() %>%
layer_dense(units = num_classes) %>%
layer_activation_softmax()
model <- keras_model(
inputs = inputs,
outputs = outputs
)
model %>% compile(
optimizer = optimizer,
loss = loss,
metrics = metrics
)
return(model)
}මෙම ප්රවේශයේ අවාසි පැහැදිලිය. මට ආකෘති ගොඩක් පරීක්ෂා කිරීමට අවශ්යයි, නමුත් ඊට ප්රතිවිරුද්ධව, එක් එක් ගෘහ නිර්මාණ ශිල්පය අතින් නැවත ලිවීමට මට අවශ්ය නැත. ඉමේජ්නෙට් මත පූර්ව පුහුණුව ලැබූ නිරූපිකාවන්ගේ බර භාවිත කිරීමේ අවස්ථාව ද අපට අහිමි විය. සුපුරුදු පරිදි, ලේඛන අධ්යයනය කිරීම උපකාරි විය. කාර්යය 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 ඉමේජ්නෙට් මත පුහුණු කරන ලද බර සහිත හෝ රහිත ආකෘති:
සූදානම් ගෘහ නිර්මාණ ශිල්පය පැටවීම සඳහා කාර්යය
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)පැකේජය docopt ක්රියාත්මක කිරීම නියෝජනය කරයි 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 වත්මන් අනුවාදයෙන් keras R භාවිතයේදී R පැකේජයේ වෙනස්කම් සැලකිල්ලට නොගත් නිසා, ඔවුන් එය නිවැරදි කරන තෙක් අපි බලා සිටිමු.
RStudio හි වඩාත් සාම්ප්‍රදායික ස්ක්‍රිප්ට් දියත් කිරීම හා සසඳන විට විවිධ මාදිලි සමඟ අත්හදා බැලීම් සැලකිය යුතු ලෙස වේගවත් කිරීමට මෙම ප්‍රවේශය හැකි විය (හැකි විකල්පයක් ලෙස අපි පැකේජය සටහන් කරමු. ) නමුත් ප්‍රධාන වාසිය නම් මේ සඳහා RStudio ස්ථාපනය නොකර Docker හි හෝ සරලව සේවාදායකයේ ස්ක්‍රිප්ට් දියත් කිරීම පහසුවෙන් කළමනාකරණය කිරීමේ හැකියාවයි.
6. ස්ක්‍රිප්ට් ඩොකරීකරණය
කණ්ඩායම් සාමාජිකයින් අතර පුහුණු ආකෘති සඳහා සහ වලාකුළෙහි වේගවත් යෙදවීම සඳහා පරිසරයේ අතේ ගෙන යා හැකි බව සහතික කිරීමට අපි ඩොකර් භාවිතා කළෙමු. R ක්‍රමලේඛකයෙකුට සාපේක්ෂව අසාමාන්‍ය වන මෙම මෙවලම සමඟ ඔබට දැන හඳුනා ගැනීම ආරම්භ කළ හැකිය ප්රකාශන මාලාවක් හෝ .
ඩොකර් ඔබට මුල සිටම ඔබේම පින්තූර සෑදීමට සහ ඔබේම නිර්මාණය සඳහා පදනමක් ලෙස වෙනත් පින්තූර භාවිතා කිරීමට ඉඩ සලසයි. පවතින විකල්ප විශ්ලේෂණය කිරීමේදී, 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
පහසුව සඳහා, භාවිතා කරන ලද පැකේජ විචල්යයන් බවට පත් කරන ලදී; ලිඛිත ස්ක්‍රිප්ට් වලින් වැඩි ප්රමාණයක් එකලස් කිරීමේදී බහාලුම් තුළ පිටපත් කරනු ලැබේ. අපි command shell එකත් වෙනස් කළා /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 $@".
ප්‍රභව දත්ත සහ දත්ත සමුදාය සහිත නාමාවලි මෙන්ම පුහුණු ආකෘති සුරැකීමේ නාමාවලිය ධාරක පද්ධතියෙන් කන්ටේනරය තුළ සවි කර ඇති අතර එමඟින් අනවශ්‍ය උපාමාරු වලින් තොරව ස්ක්‍රිප්ට් වල ප්‍රති results ල වෙත ප්‍රවේශ වීමට ඔබට ඉඩ සලසයි.
7. Google Cloud මත බහු GPU භාවිතා කිරීම
තරඟයේ එක් අංගයක් වූයේ ඉතා ඝෝෂාකාරී දත්ත (ODS slack වෙතින් @Leigh.plt වෙතින් ණයට ගත් මාතෘකා පින්තූරය බලන්න). විශාල කණ්ඩායම් මෙයට එරෙහිව සටන් කිරීමට උපකාරී වන අතර, 1 GPU සහිත පරිගණකයක අත්හදා බැලීම් කිරීමෙන් පසුව, අපි ක්ලවුඩ් හි 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 කිහිපයක් සඳහා සම්පූර්ණ මාදිලියම ශීත කිරීම සහ නැවත පුහුණු කිරීම යන සම්භාව්‍ය තාක්‍ෂණය ක්රියාත්මක කළ නොහැකි විය.
භාවිතයකින් තොරව පුහුණුව නිරීක්ෂණය කරන ලදී. tensorboard, එක් එක් යුගයට පසුව තොරතුරු සහිත නම් සහිත ලොග් පටිගත කිරීම සහ ආකෘති සුරැකීම සඳහා අපව සීමා කිරීම:
ආපසු කැඳවීම්
# Шаблон имени файла лога
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පුස්තකාලයේ වේගයෙන්.අයි); යම් උත්සාහයකින්, තෙවන පාර්ශවීය ක්රියාත්මක කිරීම් R වෙත ගෙනයාමට හැකිය, උදාහරණයක් ලෙස, ; - පෙර ලක්ෂ්‍යයේ ප්රතිඵලයක් ලෙස, GPU කිහිපයක් භාවිතා කිරීමේදී නිවැරදි පුහුණු වේගය තෝරා ගැනීමට නොහැකි විය;
- නවීන ස්නායු ජාල ගෘහ නිර්මාණ ශිල්පයේ අඩුවක් ඇත, විශේෂයෙන් ඉමේජ්නෙට් මත පෙර පුහුණු වූ ඒවා;
- කිසිඳු චක්‍රීය ප්‍රතිපත්තියක් සහ වෙනස් කොට සැලකීමේ ඉගෙනුම් අනුපාත (කොසයින් ඇනීල් කිරීම අපගේ ඉල්ලීම පරිදි විය , ඔබට ස්තුතියි ).
මෙම තරඟයෙන් ඉගෙන ගත් ප්රයෝජනවත් දේවල් මොනවාද:
- සාපේක්ෂව අඩු බලැති දෘඩාංග මත, ඔබට වේදනාවකින් තොරව විනීත (RAM ප්‍රමාණය මෙන් බොහෝ ගුණයක්) දත්ත පරිමාවන් සමඟ වැඩ කළ හැකිය. ප්ලාස්ටික් බෑගය දත්ත වගුව වගු වල ස්ථානගත වෙනස් කිරීම් හේතුවෙන් මතකය ඉතිරි කරයි, ඒවා පිටපත් කිරීම වළක්වයි, සහ නිවැරදිව භාවිතා කරන විට, එහි හැකියාවන් සෑම විටම පාහේ භාෂා ස්ක්‍රිප්ට් කිරීම සඳහා අප දන්නා සියලුම මෙවලම් අතර ඉහළම වේගය පෙන්නුම් කරයි. දත්ත සමුදායක දත්ත සුරැකීම, බොහෝ අවස්ථාවලදී, සම්පූර්ණ දත්ත කට්ටලයම RAM වෙත මිරිකා හැරීමේ අවශ්‍යතාවය ගැන කිසිසේත් නොසිතීමට ඔබට ඉඩ සලසයි.
- පැකේජය භාවිතයෙන් R හි මන්දගාමී කාර්යයන් C++ හි වේගවත් ඒවා සමඟ ප්‍රතිස්ථාපනය කළ හැකිය Rcpp. භාවිතයට අමතරව නම් RcppThread හෝ RcppParallel, අපි හරස් වේදිකා බහු-නූල් ක්රියාත්මක කිරීම් ලබා ගනිමු, එබැවින් R මට්ටමේ කේතය සමාන්තර කිරීමට අවශ්ය නොවේ.
- පැකේජය Rcpp C++ පිළිබඳ බරපතල දැනුමකින් තොරව භාවිතා කළ හැක, අවශ්ය අවමය දක්වා ඇත . වැනි සිසිල් C-පුස්තකාල ගණනාවක් සඳහා ශීර්ෂ ගොනු xtensor CRAN හි ඇත, එනම්, සූදානම් කළ ඉහළ කාර්යසාධනයක් සහිත C++ කේතය R වෙත ඒකාබද්ධ කරන ව්‍යාපෘති ක්රියාත්මක කිරීම සඳහා යටිතල පහසුකම් නිර්මාණය වෙමින් පවතී. අමතර පහසුව වන්නේ සින්ටැක්ස් උද්දීපනය සහ RStudio හි ස්ථිතික C++ කේත විශ්ලේෂකයයි.
- docopt පරාමිති සමඟ ස්වයං අන්තර්ගත ස්ක්‍රිප්ට් ධාවනය කිරීමට ඔබට ඉඩ සලසයි. මෙය දුරස්ථ සේවාදායකයක භාවිතා කිරීමට පහසුය, ඇතුළුව. ඩොකර් යටතේ. RStudio හි, ස්නායුක ජාල පුහුණු කිරීම සමඟ පැය ගණනාවක් අත්හදා බැලීම් සිදු කිරීම අපහසු වන අතර, සේවාදායකයේම IDE ස්ථාපනය කිරීම සැමවිටම යුක්ති සහගත නොවේ.
- OS සහ පුස්තකාලවල විවිධ අනුවාද සහිත සංවර්ධකයින් අතර කේත අතේ ගෙන යා හැකි සහ ප්‍රතිඵල ප්‍රතිනිෂ්පාදනය කිරීමේ හැකියාව මෙන්ම සේවාදායකයන් මත ක්රියාත්මක කිරීමේ පහසුව ඩොකර් විසින් සහතික කරයි. ඔබට එක් විධානයකින් සම්පූර්ණ පුහුණු නල මාර්ගය දියත් කළ හැකිය.
- Google Cloud යනු මිල අධික දෘඩාංග අත්හදා බැලීම සඳහා අයවැය හිතකාමී ක්‍රමයකි, නමුත් ඔබ ප්‍රවේශමෙන් වින්‍යාසයන් තෝරාගත යුතුය.
- තනි කේත කොටස්වල වේගය මැනීම ඉතා ප්රයෝජනවත් වේ, විශේෂයෙන් R සහ C++ සහ පැකේජය සමඟ ඒකාබද්ධ කිරීමේදී බංකුව - ද ඉතා පහසු.
සමස්තයක් වශයෙන් මෙම අත්දැකීම ඉතා ප්‍රතිලාභදායක වූ අතර මතු කරන ලද ගැටළු කිහිපයක් විසඳීමට අපි දිගටම කටයුතු කරන්නෙමු.
මූලාශ්රය: www.habr.com