ການຮັບຮູ້ Doodle ແຕ້ມດ່ວນ: ວິທີການສ້າງເພື່ອນກັບ R, C++ ແລະເຄືອຂ່າຍ neural

Hey Habr!

ໃນລະດູໃບໄມ້ປົ່ງທີ່ຜ່ານມາ, Kaggle ເປັນເຈົ້າພາບຈັດການແຂ່ງຂັນເພື່ອຈັດປະເພດຮູບພາບທີ່ແຕ້ມດ້ວຍມື, Quick Draw Doodle Recognition, ໃນນັ້ນ, ໃນບັນດາອື່ນໆ, ທີມນັກວິທະຍາສາດ R- ໄດ້ເຂົ້າຮ່ວມ: Artem Klevtsova, ຜູ້ຈັດການ Philippa и Andrey Ogurtsov. ພວກ​ເຮົາ​ຈະ​ບໍ່​ໄດ້​ອະ​ທິ​ບາຍ​ການ​ແຂ່ງ​ຂັນ​ໂດຍ​ລະ​ອຽດ​, ທີ່​ໄດ້​ເຮັດ​ແລ້ວ​ໃນ​ ການພິມເຜີຍແຜ່ທີ່ຜ່ານມາ.

ເວລານີ້ມັນບໍ່ໄດ້ຜົນກັບການປູກຝັງຫຼຽນ, ແຕ່ປະສົບການທີ່ມີຄຸນຄ່າຫຼາຍກໍ່ໄດ້ຮັບ, ສະນັ້ນຂ້າພະເຈົ້າຢາກບອກຊຸມຊົນກ່ຽວກັບສິ່ງທີ່ຫນ້າສົນໃຈແລະເປັນປະໂຫຍດທີ່ສຸດກ່ຽວກັບ Kagle ແລະໃນການເຮັດວຽກປະຈໍາວັນ. ໃນ​ບັນ​ດາ​ຫົວ​ຂໍ້​ທີ່​ປຶກ​ສາ​ຫາ​ລື​: ຊີ​ວິດ​ທີ່​ມີ​ຄວາມ​ຫຍຸ້ງ​ຍາກ​ໂດຍ​ບໍ່​ມີ​ການ​ OpenCV, JSON parsing (ຕົວຢ່າງເຫຼົ່ານີ້ກວດເບິ່ງການລວມລະຫັດ C++ ເຂົ້າໄປໃນ scripts ຫຼື packages ໃນ R ໂດຍໃຊ້ Rcpp), parameterization ຂອງ scripts ແລະ dockerization ຂອງການແກ້ໄຂສຸດທ້າຍ. ລະຫັດທັງຫມົດຈາກຂໍ້ຄວາມໃນຮູບແບບທີ່ເຫມາະສົມສໍາລັບການປະຕິບັດແມ່ນມີຢູ່ໃນ ຄັງເກັບມ້ຽນ.

ເນື້ອຫາ:

1. ໂຫຼດຂໍ້ມູນຈາກ CSV ເຂົ້າໄປໃນ MonetDB ຢ່າງມີປະສິດທິພາບ
2. ການກະກຽມຊຸດ
3. Iterators ສໍາລັບ unloading batches ຈາກຖານຂໍ້ມູນ
4. ການເລືອກສະຖາປັດຕະຍະກໍາແບບຈໍາລອງ
5. ການກໍານົດຕົວກໍານົດການສະຄຣິບ
6. Dockerization ຂອງ scripts
7. ໃຊ້ GPU ຫຼາຍອັນໃນ Google Cloud
8. ແທນທີ່ຈະເປັນການສະຫລຸບໄດ້

1. ໂຫຼດຂໍ້ມູນຈາກ CSV ເຂົ້າໃນຖານຂໍ້ມູນ MonetDB ຢ່າງມີປະສິດທິພາບ

ຂໍ້ມູນໃນການແຂ່ງຂັນນີ້ແມ່ນບໍ່ຢູ່ໃນຮູບແບບຂອງຮູບພາບທີ່ກຽມພ້ອມ, ແຕ່ໃນຮູບແບບຂອງ 340 ໄຟລ໌ CSV (ຫນຶ່ງໄຟລ໌ສໍາລັບແຕ່ລະຊັ້ນຮຽນ) ທີ່ມີ JSONs ທີ່ມີຈຸດປະສານງານ. ໂດຍການເຊື່ອມຕໍ່ຈຸດເຫຼົ່ານີ້ກັບເສັ້ນ, ພວກເຮົາໄດ້ຮັບຮູບພາບສຸດທ້າຍທີ່ວັດແທກ 256x256 pixels. ນອກຈາກນັ້ນ, ແຕ່ລະບັນທຶກມີປ້າຍຊີ້ບອກວ່າຮູບພາບໄດ້ຖືກຮັບຮູ້ຢ່າງຖືກຕ້ອງໂດຍຜູ້ຈັດປະເພດທີ່ໃຊ້ໃນເວລາທີ່ຊຸດຂໍ້ມູນໄດ້ຖືກເກັບກໍາ, ລະຫັດສອງຕົວອັກສອນຂອງປະເທດທີ່ຢູ່ອາໄສຂອງຜູ້ຂຽນຂອງຮູບພາບ, ຕົວລະບຸທີ່ເປັນເອກະລັກ, ສະແຕມເວລາ. ແລະຊື່ຫ້ອງຮຽນທີ່ກົງກັບຊື່ໄຟລ໌. ສະບັບທີ່ງ່າຍດາຍຂອງຂໍ້ມູນຕົ້ນສະບັບມີນໍ້າຫນັກ 7.4 GB ຢູ່ໃນບ່ອນເກັບມ້ຽນແລະປະມານ 20 GB ຫຼັງຈາກການຫຸ້ມຫໍ່, ຂໍ້ມູນເຕັມຫຼັງຈາກການຫຸ້ມຫໍ່ໃຊ້ເວລາເຖິງ 240 GB. ຜູ້​ຈັດ​ຕັ້ງ​ໄດ້​ຮັບ​ປະ​ກັນ​ວ່າ​ທັງ​ສອງ​ສະ​ບັບ​ຜະ​ລິດ​ຮູບ​ແຕ້ມ​ດຽວ​ກັນ​, ຊຶ່ງ​ຫມາຍ​ຄວາມ​ວ່າ​ສະ​ບັບ​ເຕັມ​ແມ່ນ​ຊໍ້າ​ຊ້ອນ​. ໃນກໍລະນີໃດກໍ່ຕາມ, ການເກັບຮັກສາ 50 ລ້ານຮູບພາບໃນໄຟລ໌ກຣາຟິກຫຼືໃນຮູບແບບຂອງ arrays ແມ່ນຖືວ່າບໍ່ມີຜົນປະໂຫຍດທັນທີ, ແລະພວກເຮົາໄດ້ຕັດສິນໃຈລວມໄຟລ໌ CSV ທັງຫມົດຈາກບ່ອນເກັບມ້ຽນ. train_simplified.zip ເຂົ້າ​ໄປ​ໃນ​ຖານ​ຂໍ້​ມູນ​ທີ່​ມີ​ການ​ຜະ​ລິດ​ຕໍ່​ໄປ​ຂອງ​ຮູບ​ພາບ​ຂະ​ຫນາດ​ທີ່​ຕ້ອງ​ການ "ກ່ຽວ​ກັບ​ການ​ບິນ​" ສໍາ​ລັບ​ແຕ່​ລະ batch​.

ລະບົບທີ່ພິສູດໄດ້ດີໄດ້ຖືກເລືອກເປັນ DBMS MonetDB, ຄືການປະຕິບັດສໍາລັບ R ເປັນຊຸດ MonetDBLite. ຊຸດປະກອບມີສະບັບຝັງຂອງເຄື່ອງແມ່ຂ່າຍຖານຂໍ້ມູນແລະຊ່ວຍໃຫ້ທ່ານສາມາດເອົາເຄື່ອງແມ່ຂ່າຍໂດຍກົງຈາກກອງປະຊຸມ R ແລະເຮັດວຽກກັບມັນຢູ່ທີ່ນັ້ນ. ການສ້າງຖານຂໍ້ມູນແລະການເຊື່ອມຕໍ່ກັບມັນຖືກປະຕິບັດດ້ວຍຄໍາສັ່ງດຽວ:

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

ພວກເຮົາຈະຕ້ອງສ້າງສອງຕາຕະລາງ: ຕາຕະລາງຫນຶ່ງສໍາລັບຂໍ້ມູນທັງຫມົດ, ອີກອັນຫນຶ່ງສໍາລັບຂໍ້ມູນການບໍລິການກ່ຽວກັບໄຟລ໌ທີ່ດາວໂຫລດ (ເປັນປະໂຫຍດຖ້າມີບາງຢ່າງຜິດພາດແລະຂະບວນການຕ້ອງໄດ້ສືບຕໍ່ຫຼັງຈາກດາວໂຫລດຫຼາຍໆໄຟລ໌):

ການສ້າງຕາຕະລາງ

if (!DBI::dbExistsTable(con, "doodles")) {
  DBI::dbCreateTable(
    con = con,
    name = "doodles",
    fields = c(
      "countrycode" = "char(2)",
      "drawing" = "text",
      "key_id" = "bigint",
      "recognized" = "bool",
      "timestamp" = "timestamp",
      "word" = "text"
    )
  )
}

if (!DBI::dbExistsTable(con, "upload_log")) {
  DBI::dbCreateTable(
    con = con,
    name = "upload_log",
    fields = c(
      "id" = "serial",
      "file_name" = "text UNIQUE",
      "uploaded" = "bool DEFAULT false"
    )
  )
}

ວິທີທີ່ໄວທີ່ສຸດທີ່ຈະໂຫລດຂໍ້ມູນເຂົ້າໄປໃນຖານຂໍ້ມູນແມ່ນການຄັດລອກໄຟລ໌ CSV ໂດຍກົງໂດຍໃຊ້ SQL - ຄໍາສັ່ງ COPY OFFSET 2 INTO tablename FROM path USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORTບ່ອນທີ່ tablename - ຊື່​ຕາ​ຕະ​ລາງ​ແລະ​ path - ເສັ້ນທາງໄປຫາໄຟລ໌. ໃນຂະນະທີ່ເຮັດວຽກກັບຮວບຮວມ, ມັນໄດ້ຖືກຄົ້ນພົບວ່າການກໍ່ສ້າງໃນການປະຕິບັດ unzip ໃນ R ບໍ່ເຮັດວຽກຢ່າງຖືກຕ້ອງກັບໄຟລ໌ຈໍານວນຫນຶ່ງຈາກບ່ອນເກັບມ້ຽນ, ດັ່ງນັ້ນພວກເຮົາໄດ້ໃຊ້ລະບົບ unzip (ໃຊ້ພາລາມິເຕີ getOption("unzip")).

ຟັງຊັນສໍາລັບການຂຽນໃສ່ຖານຂໍ້ມູນ

#' @title Извлечение и загрузка файлов
#'
#' @description
#' Извлечение CSV-файлов из ZIP-архива и загрузка их в базу данных
#'
#' @param con Объект подключения к базе данных (класс `MonetDBEmbeddedConnection`).
#' @param tablename Название таблицы в базе данных.
#' @oaram zipfile Путь к ZIP-архиву.
#' @oaram filename Имя файла внури ZIP-архива.
#' @param preprocess Функция предобработки, которая будет применена извлечённому файлу.
#'   Должна принимать один аргумент `data` (объект `data.table`).
#'
#' @return `TRUE`.
#'
upload_file <- function(con, tablename, zipfile, filename, preprocess = NULL) {
  # Проверка аргументов
  checkmate::assert_class(con, "MonetDBEmbeddedConnection")
  checkmate::assert_string(tablename)
  checkmate::assert_string(filename)
  checkmate::assert_true(DBI::dbExistsTable(con, tablename))
  checkmate::assert_file_exists(zipfile, access = "r", extension = "zip")
  checkmate::assert_function(preprocess, args = c("data"), null.ok = TRUE)

  # Извлечение файла
  path <- file.path(tempdir(), filename)
  unzip(zipfile, files = filename, exdir = tempdir(), 
        junkpaths = TRUE, unzip = getOption("unzip"))
  on.exit(unlink(file.path(path)))

  # Применяем функция предобработки
  if (!is.null(preprocess)) {
    .data <- data.table::fread(file = path)
    .data <- preprocess(data = .data)
    data.table::fwrite(x = .data, file = path, append = FALSE)
    rm(.data)
  }

  # Запрос к БД на импорт CSV
  sql <- sprintf(
    "COPY OFFSET 2 INTO %s FROM '%s' USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORT",
    tablename, path
  )
  # Выполнение запроса к БД
  DBI::dbExecute(con, sql)

  # Добавление записи об успешной загрузке в служебную таблицу
  DBI::dbExecute(con, sprintf("INSERT INTO upload_log(file_name, uploaded) VALUES('%s', true)",
                              filename))

  return(invisible(TRUE))
}

ຖ້າທ່ານຕ້ອງການຫັນປ່ຽນຕາຕະລາງກ່ອນທີ່ຈະຂຽນມັນໃສ່ຖານຂໍ້ມູນ, ມັນພຽງພໍທີ່ຈະຜ່ານໃນການໂຕ້ຖຽງ preprocess ຟັງຊັນທີ່ຈະປ່ຽນຂໍ້ມູນ.

ລະຫັດສໍາລັບການໂຫຼດຂໍ້ມູນຕາມລໍາດັບເຂົ້າໄປໃນຖານຂໍ້ມູນ:

ການຂຽນຂໍ້ມູນໃສ່ຖານຂໍ້ມູນ

# Список файлов для записи
files <- unzip(zipfile, list = TRUE)$Name

# Список исключений, если часть файлов уже была загружена
to_skip <- DBI::dbGetQuery(con, "SELECT file_name FROM upload_log")[[1L]]
files <- setdiff(files, to_skip)

if (length(files) > 0L) {
  # Запускаем таймер
  tictoc::tic()
  # Прогресс бар
  pb <- txtProgressBar(min = 0L, max = length(files), style = 3)
  for (i in seq_along(files)) {
    upload_file(con = con, tablename = "doodles", 
                zipfile = zipfile, filename = files[i])
    setTxtProgressBar(pb, i)
  }
  close(pb)
  # Останавливаем таймер
  tictoc::toc()
}

# 526.141 sec elapsed - копирование SSD->SSD
# 558.879 sec elapsed - копирование USB->SSD

ເວລາໂຫຼດຂໍ້ມູນອາດຈະແຕກຕ່າງກັນໄປຕາມຄຸນລັກສະນະຄວາມໄວຂອງໄດທີ່ໃຊ້. ໃນກໍລະນີຂອງພວກເຮົາ, ການອ່ານແລະການຂຽນພາຍໃນຫນຶ່ງ SSD ຫຼືຈາກ flash drive (ໄຟລ໌ແຫຼ່ງ) ໄປຫາ SSD (DB) ໃຊ້ເວລາຫນ້ອຍກວ່າ 10 ນາທີ.

ມັນໃຊ້ເວລາສອງສາມວິນາທີເພື່ອສ້າງຖັນທີ່ມີປ້າຍຊື່ຂອງຊັ້ນ integer ແລະຖັນດັດສະນີ (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)"))

ເພື່ອແກ້ໄຂບັນຫາການສ້າງ batch ສຸດບິນ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ບັນລຸຄວາມໄວສູງສຸດຂອງການສະກັດແຖວສຸ່ມຈາກຕາຕະລາງ. doodles. ສໍາລັບນີ້ພວກເຮົາໄດ້ນໍາໃຊ້ 3 tricks. ທໍາອິດແມ່ນເພື່ອຫຼຸດຜ່ອນຂະຫນາດຂອງປະເພດທີ່ເກັບຮັກສາ ID ການສັງເກດການ. ໃນຊຸດຂໍ້ມູນຕົ້ນສະບັບ, ປະເພດທີ່ຕ້ອງການເພື່ອເກັບຮັກສາ ID ແມ່ນ bigint, ແຕ່ຈໍານວນຂອງການສັງເກດການເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະເຫມາະຕົວລະບຸຂອງເຂົາເຈົ້າ, ເທົ່າກັບຈໍານວນຄໍາສັ່ງ, ເຂົ້າໄປໃນປະເພດ. int. ໃນກໍລະນີນີ້, ການຄົ້ນຫາແມ່ນໄວກວ່າ. trick ທີສອງແມ່ນການນໍາໃຊ້ ORDERED INDEX — ພວກ​ເຮົາ​ໄດ້​ເຂົ້າ​ມາ​ໃນ​ການ​ຕັດ​ສິນ​ໃຈ​ນີ້​ເປັນ​ປະ​ຈັກ​, ໂດຍ​ຜ່ານ​ການ​ທັງ​ຫມົດ​ທີ່​ມີ​ຢູ່​ ທາງເລືອກ. ອັນທີສາມແມ່ນການໃຊ້ການສອບຖາມແບບພາລາມິເຕີ. ໂດຍເນື້ອແທ້ແລ້ວຂອງວິທີການແມ່ນເພື່ອປະຕິບັດຄໍາສັ່ງຫນຶ່ງຄັ້ງ 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. ການກະກຽມຊຸດ

ຂະບວນການກະກຽມ batch ທັງຫມົດປະກອບດ້ວຍຂັ້ນຕອນດັ່ງຕໍ່ໄປນີ້:

1. parsing JSONs ຫຼາຍອັນທີ່ມີ vectors ຂອງ strings ທີ່ມີຈຸດປະສານງານ.
2. ການ​ແຕ້ມ​ເສັ້ນ​ສີ​ໂດຍ​ອີງ​ໃສ່​ການ​ປະ​ສານ​ງານ​ຂອງ​ຈຸດ​ໃນ​ຮູບ​ພາບ​ຂະ​ຫນາດ​ທີ່​ຕ້ອງ​ການ (ຕົວ​ຢ່າງ​, 256×256 ຫຼື 128×128​)​.
3. ການແປງຮູບພາບຜົນໄດ້ຮັບເຂົ້າໄປໃນ tensor.

ເປັນສ່ວນຫນຶ່ງຂອງການແຂ່ງຂັນລະຫວ່າງ Python kernels, ບັນຫາໄດ້ຖືກແກ້ໄຂຕົ້ນຕໍໂດຍໃຊ້ OpenCV. ຫນຶ່ງໃນ analogues ທີ່ງ່າຍດາຍແລະຊັດເຈນທີ່ສຸດໃນ R ຈະມີລັກສະນະນີ້:

ການ​ປະ​ຕິ​ບັດ JSON ການ​ປ່ຽນ Tensor ໃນ R

r_process_json_str <- function(json, line.width = 3, 
                               color = TRUE, scale = 1) {
  # Парсинг JSON
  coords <- jsonlite::fromJSON(json, simplifyMatrix = FALSE)
  tmp <- tempfile()
  # Удаляем временный файл по завершению функции
  on.exit(unlink(tmp))
  png(filename = tmp, width = 256 * scale, height = 256 * scale, pointsize = 1)
  # Пустой график
  plot.new()
  # Размер окна графика
  plot.window(xlim = c(256 * scale, 0), ylim = c(256 * scale, 0))
  # Цвета линий
  cols <- if (color) rainbow(length(coords)) else "#000000"
  for (i in seq_along(coords)) {
    lines(x = coords[[i]][[1]] * scale, y = coords[[i]][[2]] * scale, 
          col = cols[i], lwd = line.width)
  }
  dev.off()
  # Преобразование изображения в 3-х мерный массив
  res <- png::readPNG(tmp)
  return(res)
}

r_process_json_vector <- function(x, ...) {
  res <- lapply(x, r_process_json_str, ...)
  # Объединение 3-х мерных массивов картинок в 4-х мерный в тензор
  res <- do.call(abind::abind, c(res, along = 0))
  return(res)
}

ການແຕ້ມຮູບແມ່ນດໍາເນີນການໂດຍໃຊ້ເຄື່ອງມື R ມາດຕະຖານແລະຖືກບັນທຶກໄວ້ໃນ PNG ຊົ່ວຄາວທີ່ເກັບໄວ້ໃນ RAM (ໃນ Linux, ໄດເລກະທໍລີ R ຊົ່ວຄາວແມ່ນຢູ່ໃນໄດເລກະທໍລີ /tmp, ຕິດຕັ້ງຢູ່ໃນ RAM). ຫຼັງຈາກນັ້ນ, ໄຟລ໌ນີ້ຈະຖືກອ່ານເປັນ array ສາມມິຕິລະດັບທີ່ມີຕົວເລກຕັ້ງແຕ່ 0 ຫາ 1. ນີ້ແມ່ນສິ່ງສໍາຄັນເພາະວ່າ BMP ທໍາມະດາກວ່າຈະຖືກອ່ານເຂົ້າໄປໃນອາເຣດິບທີ່ມີລະຫັດສີ hex.

ຂໍ​ໃຫ້​ທົດ​ສອບ​ຜົນ​ໄດ້​ຮັບ​:

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

batch ຕົວຂອງມັນເອງຈະໄດ້ຮັບການສ້າງຕັ້ງຂຶ້ນດັ່ງຕໍ່ໄປນີ້:

res <- r_process_json_vector(tmp_data[1:4, drawing], scale = 0.5)
str(res)
 # num [1:4, 1:128, 1:128, 1:3] 1 1 1 1 1 1 1 1 1 1 ...
 # - attr(*, "dimnames")=List of 4
 #  ..$ : NULL
 #  ..$ : NULL
 #  ..$ : NULL
 #  ..$ : NULL

ການປະຕິບັດນີ້ເບິ່ງຄືວ່າບໍ່ເຫມາະສົມທີ່ສຸດສໍາລັບພວກເຮົາ, ນັບຕັ້ງແຕ່ການສ້າງຊຸດໃຫຍ່ໃຊ້ເວລາດົນ, ແລະພວກເຮົາໄດ້ຕັດສິນໃຈທີ່ຈະໃຊ້ປະໂຍດຈາກປະສົບການຂອງເພື່ອນຮ່ວມງານຂອງພວກເຮົາໂດຍໃຊ້ຫ້ອງສະຫມຸດທີ່ມີປະສິດທິພາບ. OpenCV. ໃນ​ເວ​ລາ​ນັ້ນ​ບໍ່​ມີ​ຊຸດ​ທີ່​ກຽມ​ພ້ອມ​ສໍາ​ລັບ R (ບໍ່​ມີ​ໃນ​ປັດ​ຈຸ​ບັນ​)​, ສະ​ນັ້ນ​ການ​ປະ​ຕິ​ບັດ​ຕໍາ​່​ສຸດ​ທີ່​ຂອງ​ການ​ທໍາ​ງານ​ທີ່​ຕ້ອງ​ການ​ໄດ້​ຖືກ​ລາຍ​ລັກ​ອັກ​ສອນ​ໃນ C ++ ກັບ​ການ​ເຊື່ອມ​ໂຍງ​ເຂົ້າ​ໄປ​ໃນ​ລະ​ຫັດ R ນໍາ​ໃຊ້​. Rcpp.

ເພື່ອແກ້ໄຂບັນຫາ, ຊຸດແລະຫ້ອງສະຫມຸດຕໍ່ໄປນີ້ໄດ້ຖືກນໍາໃຊ້:

1. OpenCV ສໍາລັບການເຮັດວຽກກັບຮູບພາບແລະການແຕ້ມເສັ້ນ. ໃຊ້ຫ້ອງສະຫມຸດລະບົບທີ່ຕິດຕັ້ງໄວ້ກ່ອນແລະໄຟລ໌ສ່ວນຫົວ, ເຊັ່ນດຽວກັນກັບການເຊື່ອມໂຍງແບບເຄື່ອນໄຫວ.

2. xtensor ສໍາລັບການເຮັດວຽກກັບ arrays multidimensional ແລະ tensors ພວກ​ເຮົາ​ໄດ້​ນໍາ​ໃຊ້​ໄຟລ​໌ header ລວມ​ຢູ່​ໃນ​ຊຸດ R ຂອງ​ຊື່​ດຽວ​ກັນ​. ຫ້ອງສະຫມຸດຊ່ວຍໃຫ້ທ່ານສາມາດເຮັດວຽກກັບອະເຣຫຼາຍມິຕິລະດັບ, ທັງໃນແຖວທີ່ສໍາຄັນແລະຖັນທີ່ສໍາຄັນ.

3. ndjson ສໍາລັບການວິເຄາະ JSON. ຫ້ອງສະຫມຸດນີ້ຖືກນໍາໃຊ້ໃນ xtensor ອັດຕະໂນມັດຖ້າມັນມີຢູ່ໃນໂຄງການ.

4. RcppThread ສໍາລັບການຈັດຕັ້ງການປະມວນຜົນຫຼາຍກະທູ້ຂອງ vector ຈາກ JSON. ໃຊ້ໄຟລ໌ສ່ວນຫົວທີ່ສະໜອງໃຫ້ໂດຍແພັກເກດນີ້. ຈາກຄວາມນິຍົມຫຼາຍຂຶ້ນ RcppParallel ຊຸດ, ໃນບັນດາສິ່ງອື່ນໆ, ມີກົນໄກການຂັດຂວາງ loop ກໍ່ສ້າງໃນ.

ມັນຄວນຈະໄດ້ຮັບຍົກໃຫ້ເຫັນວ່າ xtensor ກາຍເປັນ godsend: ນອກເຫນືອໄປຈາກຄວາມຈິງທີ່ວ່າມັນມີຫນ້າທີ່ກວ້າງຂວາງແລະປະສິດທິພາບສູງ, ນັກພັດທະນາຂອງມັນໄດ້ກາຍເປັນທີ່ຂ້ອນຂ້າງຕອບສະຫນອງແລະຕອບຄໍາຖາມທັນທີແລະລາຍລະອຽດ. ດ້ວຍການຊ່ວຍເຫຼືອຂອງພວກເຂົາ, ມັນເປັນໄປໄດ້ທີ່ຈະປະຕິບັດການຫັນປ່ຽນຂອງ OpenCV matrices ເຂົ້າໄປໃນ xtensor tensors, ເຊັ່ນດຽວກັນກັບວິທີການສົມທົບ tensor ຮູບພາບ 3 ມິຕິເຂົ້າໄປໃນ tensor 4 ມິຕິຂອງມິຕິທີ່ຖືກຕ້ອງ (batch ຕົວຂອງມັນເອງ).

ວັດສະດຸສຳລັບການຮຽນຮູ້ 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

ເພື່ອລວບລວມໄຟລ໌ທີ່ໃຊ້ໄຟລ໌ລະບົບແລະການເຊື່ອມໂຍງແບບເຄື່ອນໄຫວກັບຫ້ອງສະຫມຸດທີ່ຕິດຕັ້ງຢູ່ໃນລະບົບ, ພວກເຮົາໄດ້ນໍາໃຊ້ກົນໄກ plugin ທີ່ປະຕິບັດຢູ່ໃນຊຸດ. Rcpp. ເພື່ອຊອກຫາເສັ້ນທາງ ແລະທຸງໂດຍອັດຕະໂນມັດ, ພວກເຮົາໄດ້ໃຊ້ເຄື່ອງໃຊ້ Linux ທີ່ເປັນທີ່ນິຍົມ pkg-config.

ການປະຕິບັດຂອງ plugin Rcpp ສໍາລັບການນໍາໃຊ້ຫ້ອງສະຫມຸດ OpenCV

Rcpp::registerPlugin("opencv", function() {
  # Возможные названия пакета
  pkg_config_name <- c("opencv", "opencv4")
  # Бинарный файл утилиты pkg-config
  pkg_config_bin <- Sys.which("pkg-config")
  # Проврека наличия утилиты в системе
  checkmate::assert_file_exists(pkg_config_bin, access = "x")
  # Проверка наличия файла настроек OpenCV для pkg-config
  check <- sapply(pkg_config_name, 
                  function(pkg) system(paste(pkg_config_bin, pkg)))
  if (all(check != 0)) {
    stop("OpenCV config for the pkg-config not found", call. = FALSE)
  }

  pkg_config_name <- pkg_config_name[check == 0]
  list(env = list(
    PKG_CXXFLAGS = system(paste(pkg_config_bin, "--cflags", pkg_config_name), 
                          intern = TRUE),
    PKG_LIBS = system(paste(pkg_config_bin, "--libs", pkg_config_name), 
                      intern = TRUE)
  ))
})

ເປັນຜົນມາຈາກການດໍາເນີນງານຂອງ plugin, ຄ່າຕໍ່ໄປນີ້ຈະຖືກທົດແທນໃນລະຫວ່າງຂະບວນການລວບລວມ:

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 ແລະ​ການ​ສ້າງ batch ສໍາ​ລັບ​ການ​ສົ່ງ​ກັບ​ຮູບ​ແບບ​ແມ່ນ​ໄດ້​ຮັບ​ໃຫ້​ພາຍ​ໃຕ້ spoiler ໄດ້​. ທໍາອິດ, ເພີ່ມບັນຊີໂຄງການທ້ອງຖິ່ນເພື່ອຊອກຫາໄຟລ໌ header (ຕ້ອງການສໍາລັບ ndjson):

Sys.setenv("PKG_CXXFLAGS" = paste0("-I", normalizePath(file.path("src"))))

ການປະຕິບັດ JSON ໃນການແປງ tensor ໃນ C++

// [[Rcpp::plugins(cpp14)]]
// [[Rcpp::plugins(opencv)]]
// [[Rcpp::depends(xtensor)]]
// [[Rcpp::depends(RcppThread)]]

#include <xtensor/xjson.hpp>
#include <xtensor/xadapt.hpp>
#include <xtensor/xview.hpp>
#include <xtensor-r/rtensor.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <Rcpp.h>
#include <RcppThread.h>

// Синонимы для типов
using RcppThread::parallelFor;
using json = nlohmann::json;
using points = xt::xtensor<double,2>;     // Извлечённые из JSON координаты точек
using strokes = std::vector<points>;      // Извлечённые из JSON координаты точек
using xtensor3d = xt::xtensor<double, 3>; // Тензор для хранения матрицы изоображения
using xtensor4d = xt::xtensor<double, 4>; // Тензор для хранения множества изображений
using rtensor3d = xt::rtensor<double, 3>; // Обёртка для экспорта в R
using rtensor4d = xt::rtensor<double, 4>; // Обёртка для экспорта в R

// Статические константы
// Размер изображения в пикселях
const static int SIZE = 256;
// Тип линии
// См. https://en.wikipedia.org/wiki/Pixel_connectivity#2-dimensional
const static int LINE_TYPE = cv::LINE_4;
// Толщина линии в пикселях
const static int LINE_WIDTH = 3;
// Алгоритм ресайза
// https://docs.opencv.org/3.1.0/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121
const static int RESIZE_TYPE = cv::INTER_LINEAR;

// Шаблон для конвертирования OpenCV-матрицы в тензор
template <typename T, int NCH, typename XT=xt::xtensor<T,3,xt::layout_type::column_major>>
XT to_xt(const cv::Mat_<cv::Vec<T, NCH>>& src) {
  // Размерность целевого тензора
  std::vector<int> shape = {src.rows, src.cols, NCH};
  // Общее количество элементов в массиве
  size_t size = src.total() * NCH;
  // Преобразование cv::Mat в xt::xtensor
  XT res = xt::adapt((T*) src.data, size, xt::no_ownership(), shape);
  return res;
}

// Преобразование JSON в список координат точек
strokes parse_json(const std::string& x) {
  auto j = json::parse(x);
  // Результат парсинга должен быть массивом
  if (!j.is_array()) {
    throw std::runtime_error("'x' must be JSON array.");
  }
  strokes res;
  res.reserve(j.size());
  for (const auto& a: j) {
    // Каждый элемент массива должен быть 2-мерным массивом
    if (!a.is_array() || a.size() != 2) {
      throw std::runtime_error("'x' must include only 2d arrays.");
    }
    // Извлечение вектора точек
    auto p = a.get<points>();
    res.push_back(p);
  }
  return res;
}

// Отрисовка линий
// Цвета HSV
cv::Mat ocv_draw_lines(const strokes& x, bool color = true) {
  // Исходный тип матрицы
  auto stype = color ? CV_8UC3 : CV_8UC1;
  // Итоговый тип матрицы
  auto dtype = color ? CV_32FC3 : CV_32FC1;
  auto bg = color ? cv::Scalar(0, 0, 255) : cv::Scalar(255);
  auto col = color ? cv::Scalar(0, 255, 220) : cv::Scalar(0);
  cv::Mat img = cv::Mat(SIZE, SIZE, stype, bg);
  // Количество линий
  size_t n = x.size();
  for (const auto& s: x) {
    // Количество точек в линии
    size_t n_points = s.shape()[1];
    for (size_t i = 0; i < n_points - 1; ++i) {
      // Точка начала штриха
      cv::Point from(s(0, i), s(1, i));
      // Точка окончания штриха
      cv::Point to(s(0, i + 1), s(1, i + 1));
      // Отрисовка линии
      cv::line(img, from, to, col, LINE_WIDTH, LINE_TYPE);
    }
    if (color) {
      // Меняем цвет линии
      col[0] += 180 / n;
    }
  }
  if (color) {
    // Меняем цветовое представление на RGB
    cv::cvtColor(img, img, cv::COLOR_HSV2RGB);
  }
  // Меняем формат представления на float32 с диапазоном [0, 1]
  img.convertTo(img, dtype, 1 / 255.0);
  return img;
}

// Обработка JSON и получение тензора с данными изображения
xtensor3d process(const std::string& x, double scale = 1.0, bool color = true) {
  auto p = parse_json(x);
  auto img = ocv_draw_lines(p, color);
  if (scale != 1) {
    cv::Mat out;
    cv::resize(img, out, cv::Size(), scale, scale, RESIZE_TYPE);
    cv::swap(img, out);
    out.release();
  }
  xtensor3d arr = color ? to_xt<double,3>(img) : to_xt<double,1>(img);
  return arr;
}

// [[Rcpp::export]]
rtensor3d cpp_process_json_str(const std::string& x, 
                               double scale = 1.0, 
                               bool color = true) {
  xtensor3d res = process(x, scale, color);
  return res;
}

// [[Rcpp::export]]
rtensor4d cpp_process_json_vector(const std::vector<std::string>& x, 
                                  double scale = 1.0, 
                                  bool color = false) {
  size_t n = x.size();
  size_t dim = floor(SIZE * scale);
  size_t channels = color ? 3 : 1;
  xtensor4d res({n, dim, dim, channels});
  parallelFor(0, n, [&x, &res, scale, color](int i) {
    xtensor3d tmp = process(x[i], scale, color);
    auto view = xt::view(res, i, xt::all(), xt::all(), xt::all());
    view = tmp;
  });
  return res;
}

ລະຫັດນີ້ຄວນຈະຖືກວາງໄວ້ໃນໄຟລ໌ src/cv_xt.cpp ແລະລວບລວມກັບຄໍາສັ່ງ Rcpp::sourceCpp(file = "src/cv_xt.cpp", env = .GlobalEnv); ຍັງຕ້ອງການສໍາລັບການເຮັດວຽກ nlohmann/json.hpp ຈາກນັ້ນ ຄັງເກັບມ້ຽນ. ລະຫັດຖືກແບ່ງອອກເປັນຫຼາຍຫນ້າທີ່:

• to_xt - ຫນ້າ​ທີ່​ແມ່​ແບບ​ສໍາ​ລັບ​ການ​ຫັນ​ຮູບ​ພາບ matrix (cv::Mat) ກັບ tensor ເປັນ xt::xtensor;

• parse_json — ຟັງຊັນ parses a JSON string, ສະກັດຈຸດປະສານງານຂອງຈຸດ, packing ໃຫ້ເຂົາເຈົ້າເຂົ້າໄປໃນ vector;

• ocv_draw_lines - ຈາກ vector ຜົນໄດ້ຮັບຂອງຈຸດ, draws ສາຍຫຼາຍສີ;

• process — ລວມ​ຫນ້າ​ທີ່​ຂ້າງ​ເທິງ​ນີ້​ແລະ​ຍັງ​ເພີ່ມ​ຄວາມ​ສາ​ມາດ​ໃນ​ຂະ​ຫນາດ​ຮູບ​ພາບ​ທີ່​ໄດ້​ຮັບ​;

• cpp_process_json_str - wrapper ໃນໄລຍະການທໍາງານ process, ເຊິ່ງສົ່ງອອກຜົນໄດ້ຮັບໄປຫາ R-object (ອາເຣ multidimensional);

• cpp_process_json_vector - wrapper ໃນໄລຍະການທໍາງານ cpp_process_json_str, ເຊິ່ງອະນຸຍາດໃຫ້ທ່ານສາມາດປະມວນຜົນ vector string ໃນຮູບແບບຫຼາຍ threaded.

ເພື່ອແຕ້ມເສັ້ນຫຼາຍສີ, ຮູບແບບສີ HSV ໄດ້ຖືກນໍາໃຊ້, ປະຕິບັດຕາມໂດຍການປ່ຽນເປັນ RGB. ຂໍ​ໃຫ້​ທົດ​ສອບ​ຜົນ​ໄດ້​ຮັບ​:

arr <- cpp_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256   3
plot(magick::image_read(arr))

ການປຽບທຽບຄວາມໄວຂອງການຈັດຕັ້ງປະຕິບັດໃນ R ແລະ C++

res_bench <- bench::mark(
  r_process_json_str(tmp_data[4, drawing], scale = 0.5),
  cpp_process_json_str(tmp_data[4, drawing], scale = 0.5),
  check = FALSE,
  min_iterations = 100
)
# Параметры бенчмарка
cols <- c("expression", "min", "median", "max", "itr/sec", "total_time", "n_itr")
res_bench[, cols]

#   expression                min     median       max `itr/sec` total_time  n_itr
#   <chr>                <bch:tm>   <bch:tm>  <bch:tm>     <dbl>   <bch:tm>  <int>
# 1 r_process_json_str     3.49ms     3.55ms    4.47ms      273.      490ms    134
# 2 cpp_process_json_str   1.94ms     2.02ms    5.32ms      489.      497ms    243

library(ggplot2)
# Проведение замера
res_bench <- bench::press(
  batch_size = 2^(4:10),
  {
    .data <- tmp_data[sample(seq_len(.N), batch_size), drawing]
    bench::mark(
      r_process_json_vector(.data, scale = 0.5),
      cpp_process_json_vector(.data,  scale = 0.5),
      min_iterations = 50,
      check = FALSE
    )
  }
)

res_bench[, cols]

#    expression   batch_size      min   median      max `itr/sec` total_time n_itr
#    <chr>             <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
#  1 r                   16   50.61ms  53.34ms  54.82ms    19.1     471.13ms     9
#  2 cpp                 16    4.46ms   5.39ms   7.78ms   192.      474.09ms    91
#  3 r                   32   105.7ms 109.74ms 212.26ms     7.69        6.5s    50
#  4 cpp                 32    7.76ms  10.97ms  15.23ms    95.6     522.78ms    50
#  5 r                   64  211.41ms 226.18ms 332.65ms     3.85      12.99s    50
#  6 cpp                 64   25.09ms  27.34ms  32.04ms    36.0        1.39s    50
#  7 r                  128   534.5ms 627.92ms 659.08ms     1.61      31.03s    50
#  8 cpp                128   56.37ms  58.46ms  66.03ms    16.9        2.95s    50
#  9 r                  256     1.15s    1.18s    1.29s     0.851     58.78s    50
# 10 cpp                256  114.97ms 117.39ms 130.09ms     8.45       5.92s    50
# 11 r                  512     2.09s    2.15s    2.32s     0.463       1.8m    50
# 12 cpp                512  230.81ms  235.6ms 261.99ms     4.18      11.97s    50
# 13 r                 1024        4s    4.22s     4.4s     0.238       3.5m    50
# 14 cpp               1024  410.48ms 431.43ms 462.44ms     2.33      21.45s    50

ggplot(res_bench, aes(x = factor(batch_size), y = median, 
                      group =  expression, color = expression)) +
  geom_point() +
  geom_line() +
  ylab("median time, s") +
  theme_minimal() +
  scale_color_discrete(name = "", labels = c("cpp", "r")) +
  theme(legend.position = "bottom") 

ດັ່ງທີ່ເຈົ້າສາມາດເຫັນໄດ້, ການເພີ່ມຄວາມໄວໄດ້ກາຍເປັນສິ່ງສໍາຄັນຫຼາຍ, ແລະມັນເປັນໄປບໍ່ໄດ້ທີ່ຈະຈັບລະຫັດ C ++ ໂດຍການຂະຫນານລະຫັດ R.

3. Iterators ສໍາລັບ unloading batches ຈາກຖານຂໍ້ມູນ

R ມີຊື່ສຽງທີ່ສົມຄວນສໍາລັບການປະມວນຜົນຂໍ້ມູນທີ່ເຫມາະກັບ RAM, ໃນຂະນະທີ່ Python ມີລັກສະນະເພີ່ມເຕີມໂດຍການປະມວນຜົນຂໍ້ມູນແບບຊໍ້າໆ, ຊ່ວຍໃຫ້ທ່ານສາມາດປະຕິບັດການຄິດໄລ່ນອກຫຼັກ (ການຄິດໄລ່ໂດຍໃຊ້ຫນ່ວຍຄວາມຈໍາພາຍນອກ). ຕົວຢ່າງຄລາສສິກແລະທີ່ກ່ຽວຂ້ອງສໍາລັບພວກເຮົາໃນສະພາບການຂອງບັນຫາທີ່ອະທິບາຍໄວ້ແມ່ນເຄືອຂ່າຍ neural ເລິກທີ່ໄດ້ຮັບການຝຶກອົບຮົມໂດຍວິທີການ gradient descent ໂດຍປະມານຂອງ gradient ໃນແຕ່ລະຂັ້ນຕອນໂດຍໃຊ້ສ່ວນນ້ອຍໆຂອງການສັງເກດການ, ຫຼື mini-batch.

ກອບການຮຽນຮູ້ເລິກທີ່ຂຽນໃນ Python ມີຫ້ອງຮຽນພິເສດທີ່ປະຕິບັດ iterators ໂດຍອີງໃສ່ຂໍ້ມູນ: ຕາຕະລາງ, ຮູບພາບໃນໂຟນເດີ, ຮູບແບບຖານສອງ, ແລະອື່ນໆ. ທ່ານສາມາດນໍາໃຊ້ທາງເລືອກທີ່ກຽມພ້ອມຫຼືຂຽນຂອງທ່ານເອງສໍາລັບວຽກງານສະເພາະ. ໃນ R ພວກເຮົາສາມາດໃຊ້ປະໂຫຍດຈາກລັກສະນະທັງຫມົດຂອງຫ້ອງສະຫມຸດ Python keras ກັບ backends ຕ່າງໆຂອງມັນໂດຍໃຊ້ຊຸດຂອງຊື່ດຽວກັນ, ເຊິ່ງໃນນັ້ນເຮັດວຽກຢູ່ເທິງສຸດຂອງຊຸດ reticulate. ສຸດທ້າຍສົມຄວນໄດ້ຮັບບົດຄວາມຍາວແຍກຕ່າງຫາກ; ມັນບໍ່ພຽງແຕ່ອະນຸຍາດໃຫ້ທ່ານສາມາດເອີ້ນໃຊ້ລະຫັດ Python ຈາກ R, ແຕ່ຍັງຊ່ວຍໃຫ້ທ່ານສາມາດໂອນວັດຖຸລະຫວ່າງ R ແລະ Python sessions, ອັດຕະໂນມັດການແປງປະເພດທີ່ຈໍາເປັນທັງຫມົດ.

ພວກເຮົາກໍາຈັດຄວາມຕ້ອງການທີ່ຈະເກັບຮັກສາຂໍ້ມູນທັງຫມົດໃນ RAM ໂດຍໃຊ້ MonetDBLite, ການເຮັດວຽກ "ເຄືອຂ່າຍ neural" ທັງຫມົດຈະຖືກປະຕິບັດໂດຍລະຫັດຕົ້ນສະບັບໃນ Python, ພວກເຮົາພຽງແຕ່ຕ້ອງຂຽນ iterator ໃນໄລຍະຂໍ້ມູນ, ເນື່ອງຈາກວ່າບໍ່ມີຫຍັງພ້ອມ. ສໍາລັບສະຖານະການດັ່ງກ່າວໃນ R ຫຼື Python. ມັນມີຄວາມຕ້ອງການພຽງແຕ່ສອງຢ່າງເທົ່ານັ້ນ: ມັນຕ້ອງກັບຄືນ batches ໃນ loop ທີ່ບໍ່ມີທີ່ສິ້ນສຸດແລະປະຫຍັດສະຖານະຂອງມັນລະຫວ່າງການຊໍ້າຄືນ (ອັນສຸດທ້າຍໃນ R ຖືກປະຕິບັດໃນວິທີທີ່ງ່າຍທີ່ສຸດໂດຍໃຊ້ການປິດ). ກ່ອນຫນ້ານີ້, ມັນຈໍາເປັນຕ້ອງໄດ້ປ່ຽນ R arrays ເຂົ້າໄປໃນ numpy arrays ພາຍໃນ iterator, ແຕ່ຊຸດປະຈຸບັນຂອງຊຸດ. keras ເຮັດມັນເອງ.

ຜູ້ກວດສອບຂໍ້ມູນການຝຶກອົບຮົມ ແລະການກວດສອບຄວາມຖືກຕ້ອງໄດ້ອອກເປັນດັ່ງຕໍ່ໄປນີ້:

Iterator ສໍາລັບການຝຶກອົບຮົມແລະຂໍ້ມູນການກວດສອບ

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

ຟັງຊັນໃຊ້ເວລາເປັນ input ຕົວແປທີ່ມີການເຊື່ອມຕໍ່ກັບຖານຂໍ້ມູນ, ຈໍານວນຂອງສາຍທີ່ໃຊ້, ຈໍານວນຂອງຫ້ອງຮຽນ, batch ຂະຫນາດ, ຂະຫນາດ (scale = 1 ສອດຄ້ອງກັບການສະແດງຮູບພາບຂອງ 256x256 pixels, scale = 0.5 - 128x128 pixels), ຕົວຊີ້ບອກສີ (.color = FALSE ລະບຸການສະແດງຜົນເປັນສີເທົາເມື່ອໃຊ້ color = TRUE ແຕ່ລະຈັງຫວະຖືກແຕ້ມດ້ວຍສີໃໝ່) ແລະຕົວຊີ້ບອກການປະມວນຜົນລ່ວງໜ້າສຳລັບເຄືອຂ່າຍທີ່ໄດ້ຮັບການຝຶກອົບຮົມໃນ imagenet. ອັນສຸດທ້າຍແມ່ນຈໍາເປັນເພື່ອຂະຫນາດຄ່າ pixels ​​ລວງຈາກໄລຍະ [0, 1] ໄປຫາໄລຍະ [-1, 1], ເຊິ່ງໄດ້ຖືກນໍາໃຊ້ໃນເວລາຝຶກອົບຮົມທີ່ສະຫນອງ. keras ແບບ.

ຟັງຊັນພາຍນອກປະກອບດ້ວຍການກວດສອບປະເພດການໂຕ້ຖຽງ, ຕາຕະລາງ data.table ດ້ວຍຕົວເລກເສັ້ນປະສົມແບບສຸ່ມຈາກ samples_index ແລະຈໍານວນ batch, counter ແລະຈໍານວນສູງສຸດຂອງ batches, ເຊັ່ນດຽວກັນກັບການສະແດງອອກ SQL ສໍາລັບ unloading ຂໍ້ມູນຈາກຖານຂໍ້ມູນ. ນອກຈາກນັ້ນ, ພວກເຮົາໄດ້ກໍານົດການປຽບທຽບໄວຂອງຫນ້າທີ່ພາຍໃນ keras::to_categorical(). ພວກເຮົາໄດ້ນໍາໃຊ້ຂໍ້ມູນເກືອບທັງຫມົດສໍາລັບການຝຶກອົບຮົມ, ປ່ອຍໃຫ້ເຄິ່ງຫນຶ່ງເປີເຊັນສໍາລັບການກວດສອບ, ດັ່ງນັ້ນຂະຫນາດ epoch ໄດ້ຖືກຈໍາກັດໂດຍພາລາມິເຕີ. steps_per_epoch ເມື່ອເອີ້ນ keras::fit_generator(), ແລະເງື່ອນໄຂ if (i > max_i) ພຽງແຕ່ເຮັດວຽກສໍາລັບ validation iterator.

ໃນຟັງຊັນພາຍໃນ, ດັດຊະນີແຖວຖືກດຶງມາສໍາລັບຊຸດຕໍ່ໄປ, ບັນທຶກຖືກຍົກເລີກຈາກຖານຂໍ້ມູນທີ່ມີການນັບຈໍານວນເພີ່ມຂຶ້ນ, JSON parsing (function cpp_process_json_vector(), ຂຽນໃນ C ++) ແລະການສ້າງ array ທີ່ສອດຄ້ອງກັນກັບຮູບພາບ. ຫຼັງຈາກນັ້ນ, vectors ຮ້ອນຫນຶ່ງທີ່ມີປ້າຍຊັ້ນຖືກສ້າງຂື້ນ, arrays ທີ່ມີຄ່າ pixels ​​ແລະ labels ຖືກລວມເຂົ້າກັນໃນບັນຊີລາຍຊື່, ຊຶ່ງເປັນມູນຄ່າກັບຄືນ. ເພື່ອເລັ່ງການເຮັດວຽກ, ພວກເຮົາໄດ້ນໍາໃຊ້ການສ້າງດັດສະນີໃນຕາຕະລາງ data.table ແລະການດັດແກ້ຜ່ານການເຊື່ອມຕໍ່ - ໂດຍບໍ່ມີຊຸດເຫຼົ່ານີ້ "chips" ຕາຕະລາງ ມັນຂ້ອນຂ້າງຍາກທີ່ຈະຈິນຕະນາການເຮັດວຽກຢ່າງມີປະສິດທິພາບກັບຂໍ້ມູນຈໍານວນຫຼວງຫຼາຍໃນ R.

ຜົນຂອງການວັດແທກຄວາມໄວໃນຄອມພິວເຕີ Core i5 ມີດັ່ງນີ້:

Iterator benchmark

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. ໃຫ້ແນ່ໃຈວ່າ reboot ແລະກວດເບິ່ງຜົນໄດ້ຮັບໂດຍການແລ່ນຄໍາສັ່ງ df -h.

iterator ສໍາລັບຂໍ້ມູນການທົດສອບເບິ່ງງ່າຍດາຍຫຼາຍ, ເນື່ອງຈາກວ່າຊຸດຂໍ້ມູນການທົດສອບເຫມາະທັງຫມົດເຂົ້າໄປໃນ RAM:

Iterator ສໍາລັບຂໍ້ມູນການທົດສອບ

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

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

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

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

4. ການຄັດເລືອກສະຖາປັດຕະຍະກໍາແບບຈໍາລອງ

ສະຖາປັດຕະຍະກໍາທໍາອິດທີ່ໃຊ້ແມ່ນ mobilenet v1, ລັກສະນະທີ່ໄດ້ຖືກປຶກສາຫາລືໃນ ນີ້ ຂໍ້ຄວາມ. ມັນໄດ້ຖືກລວມເຂົ້າເປັນມາດຕະຖານ keras ແລະ, ຕາມຄວາມເຫມາະສົມ, ແມ່ນມີຢູ່ໃນຊຸດຂອງຊື່ດຽວກັນສໍາລັບ R. ແຕ່ເມື່ອພະຍາຍາມໃຊ້ມັນກັບຮູບພາບຊ່ອງດຽວ, ສິ່ງແປກປະຫລາດໄດ້ຫັນອອກ: tensor ປ້ອນຂໍ້ມູນຕ້ອງມີຂະຫນາດສະເຫມີ. (batch, height, width, 3), ນັ້ນແມ່ນ, ຈໍານວນຊ່ອງບໍ່ສາມາດປ່ຽນແປງໄດ້. ບໍ່ມີຂໍ້ ຈຳ ກັດດັ່ງກ່າວໃນ Python, ສະນັ້ນພວກເຮົາຈຶ່ງຟ້າວຂຽນການຈັດຕັ້ງປະຕິບັດສະຖາປັດຕະຍະ ກຳ ຂອງພວກເຮົາເອງ, ປະຕິບັດຕາມບົດຄວາມຕົ້ນສະບັບ (ໂດຍບໍ່ມີການເລື່ອນລົງໃນສະບັບ keras):

ສະຖາປັດຕະຍະກຳ Mobilenet v1

library(keras)

top_3_categorical_accuracy <- custom_metric(
    name = "top_3_categorical_accuracy",
    metric_fn = function(y_true, y_pred) {
         metric_top_k_categorical_accuracy(y_true, y_pred, k = 3)
    }
)

layer_sep_conv_bn <- function(object, 
                              filters,
                              alpha = 1,
                              depth_multiplier = 1,
                              strides = c(2, 2)) {

  # NB! depth_multiplier !=  resolution multiplier
  # https://github.com/keras-team/keras/issues/10349

  layer_depthwise_conv_2d(
    object = object,
    kernel_size = c(3, 3), 
    strides = strides,
    padding = "same",
    depth_multiplier = depth_multiplier
  ) %>%
  layer_batch_normalization() %>% 
  layer_activation_relu() %>%
  layer_conv_2d(
    filters = filters * alpha,
    kernel_size = c(1, 1), 
    strides = c(1, 1)
  ) %>%
  layer_batch_normalization() %>% 
  layer_activation_relu() 
}

get_mobilenet_v1 <- function(input_shape = c(224, 224, 1),
                             num_classes = 340,
                             alpha = 1,
                             depth_multiplier = 1,
                             optimizer = optimizer_adam(lr = 0.002),
                             loss = "categorical_crossentropy",
                             metrics = c("categorical_crossentropy",
                                         top_3_categorical_accuracy)) {

  inputs <- layer_input(shape = input_shape)

  outputs <- inputs %>%
    layer_conv_2d(filters = 32, kernel_size = c(3, 3), strides = c(2, 2), padding = "same") %>%
    layer_batch_normalization() %>% 
    layer_activation_relu() %>%
    layer_sep_conv_bn(filters = 64, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 128, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 128, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 256, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 256, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 512, strides = c(1, 1)) %>%
    layer_sep_conv_bn(filters = 1024, strides = c(2, 2)) %>%
    layer_sep_conv_bn(filters = 1024, strides = c(1, 1)) %>%
    layer_global_average_pooling_2d() %>%
    layer_dense(units = num_classes) %>%
    layer_activation_softmax()

    model <- keras_model(
      inputs = inputs,
      outputs = outputs
    )

    model %>% compile(
      optimizer = optimizer,
      loss = loss,
      metrics = metrics
    )

    return(model)
}

ຂໍ້ເສຍຂອງວິທີການນີ້ແມ່ນເຫັນໄດ້ຊັດເຈນ. ຂ້ອຍຕ້ອງການທົດສອບຫຼາຍແບບ, ແຕ່ໃນທາງກົງກັນຂ້າມ, ຂ້ອຍບໍ່ຕ້ອງການທີ່ຈະຂຽນຄືນໃຫມ່ແຕ່ລະສະຖາປັດຕະຍະກໍາດ້ວຍຕົນເອງ. ພວກເຮົາຍັງຂາດໂອກາດທີ່ຈະໃຊ້ນໍ້າໜັກຂອງຕົວແບບທີ່ໄດ້ຝຶກອົບຮົມໄວ້ລ່ວງໜ້າໃນ imagenet. ຕາມປົກກະຕິ, ການສຶກສາເອກະສານຊ່ວຍ. ຟັງຊັນ get_config() ອະນຸຍາດໃຫ້ທ່ານໄດ້ຮັບລາຍລະອຽດຂອງຮູບແບບໃນຮູບແບບທີ່ເຫມາະສົມສໍາລັບການດັດແກ້ (base_model_conf$layers - ບັນຊີລາຍຊື່ R ປົກກະຕິ), ແລະຫນ້າທີ່ from_config() ປະຕິບັດການແປງປີ້ນກັບວັດຖຸແບບຈໍາລອງ:

base_model_conf <- get_config(base_model)
base_model_conf$layers[[1]]$config$batch_input_shape[[4]] <- 1L
base_model <- from_config(base_model_conf)

ໃນປັດຈຸບັນມັນບໍ່ຍາກທີ່ຈະຂຽນຫນ້າທີ່ທົ່ວໆໄປເພື່ອໃຫ້ໄດ້ສິ່ງທີ່ສະຫນອງໃຫ້ 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 arrays, ປ່ຽນຂະຫນາດຂອງອົງປະກອບທໍາອິດຂອງບັນຊີລາຍຊື່ນີ້ (ໂດຍການເອົາຊ່ອງສີຫນຶ່ງຫຼືສະເລ່ຍທັງສາມ), ແລະຫຼັງຈາກນັ້ນໂຫຼດນ້ໍາຫນັກຄືນເຂົ້າໄປໃນຕົວແບບທີ່ມີຟັງຊັນ. set_weights(). ພວກເຮົາບໍ່ເຄີຍເພີ່ມການເຮັດວຽກນີ້, ເພາະວ່າໃນຂັ້ນຕອນນີ້ມັນຈະແຈ້ງແລ້ວວ່າມັນມີປະສິດທິພາບຫຼາຍທີ່ຈະເຮັດວຽກກັບຮູບພາບສີ.

ພວກເຮົາໄດ້ດໍາເນີນການທົດລອງສ່ວນໃຫຍ່ໂດຍໃຊ້ mobilenet ຮຸ່ນ 1 ແລະ 2, ເຊັ່ນດຽວກັນກັບ resnet34. ສະຖາປັດຕະຍະກໍາທີ່ທັນສະໄຫມຫຼາຍເຊັ່ນ SE-ResNeXt ປະຕິບັດໄດ້ດີໃນການແຂ່ງຂັນນີ້. ແຕ່ຫນ້າເສຍດາຍ, ພວກເຮົາບໍ່ມີການປະຕິບັດທີ່ກຽມພ້ອມສໍາລັບການກໍາຈັດຂອງພວກເຮົາ, ແລະພວກເຮົາບໍ່ໄດ້ຂຽນຂອງພວກເຮົາເອງ (ແຕ່ພວກເຮົາຈະຂຽນແນ່ນອນ).

5. Parameterization ຂອງ scripts

ເພື່ອຄວາມສະດວກ, ລະຫັດທັງໝົດສໍາລັບການເລີ່ມຕົ້ນການຝຶກອົບຮົມໄດ້ຖືກອອກແບບເປັນ script ດຽວ, ໂດຍນໍາໃຊ້ຕົວກໍານົດການ docopt ດັ່ງຕໍ່ໄປນີ້:

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)

Package docopt ເປັນຕົວແທນຂອງການປະຕິບັດ http://docopt.org/ ສໍາລັບ R. ດ້ວຍການຊ່ວຍເຫຼືອຂອງມັນ, scripts ຖືກເປີດຕົວດ້ວຍຄໍາສັ່ງງ່າຍໆເຊັ່ນ 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 pixels, ຖານຂໍ້ມູນຈະຕ້ອງຢູ່ໃນໂຟນເດີ. /home/andrey/doodle_db). ທ່ານ​ສາ​ມາດ​ເພີ່ມ​ຄວາມ​ໄວ​ການ​ຮຽນ​ຮູ້​, ປະ​ເພດ optimizer , ແລະ​ຕົວ​ກໍາ​ນົດ​ການ​ປັບ​ແຕ່ງ​ອື່ນໆ​ໃນ​ບັນ​ຊີ​ລາຍ​ການ​. ໃນຂະບວນການກະກຽມການພິມເຜີຍແຜ່, ມັນໄດ້ຫັນອອກວ່າສະຖາປັດຕະ mobilenet_v2 ຈາກ​ສະ​ບັບ​ປະ​ຈຸ​ບັນ​ keras ໃນ R ໃຊ້ ສາມາດບໍ່ໄດ້ ເນື່ອງຈາກການປ່ຽນແປງທີ່ບໍ່ໄດ້ພິຈາລະນາໃນຊຸດ R, ພວກເຮົາລໍຖ້າໃຫ້ພວກເຂົາແກ້ໄຂມັນ.

ວິທີການນີ້ເຮັດໃຫ້ມັນເປັນໄປໄດ້ທີ່ຈະເລັ່ງການທົດລອງທີ່ມີຮູບແບບທີ່ແຕກຕ່າງກັນຢ່າງຫຼວງຫຼາຍເມື່ອທຽບກັບການເປີດຕົວແບບດັ້ງເດີມຂອງ scripts ໃນ RStudio (ພວກເຮົາສັງເກດເຫັນຊຸດທີ່ເປັນທາງເລືອກທີ່ເປັນໄປໄດ້. tfruns). ແຕ່ປະໂຫຍດຕົ້ນຕໍແມ່ນຄວາມສາມາດໃນການຈັດການການເປີດຕົວຂອງສະຄິບໃນ Docker ໄດ້ຢ່າງງ່າຍດາຍຫຼືພຽງແຕ່ຢູ່ໃນເຄື່ອງແມ່ຂ່າຍ, ໂດຍບໍ່ມີການຕິດຕັ້ງ RStudio ສໍາລັບການນີ້.

6. Dockerization ຂອງ scripts

ພວກເຮົາໄດ້ໃຊ້ 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. ນີ້ຫຼີກເວັ້ນຄວາມຕ້ອງການທີ່ຈະລະບຸສະບັບ OS ໃນລະຫັດ.

ນອກຈາກນັ້ນ, script bash ຂະຫນາດນ້ອຍໄດ້ຖືກຂຽນໄວ້ທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດເປີດຕົວ container ທີ່ມີຄໍາສັ່ງຕ່າງໆ. ສໍາລັບຕົວຢ່າງ, ເຫຼົ່ານີ້ສາມາດເປັນສະຄິບສໍາລັບການຝຶກອົບຮົມເຄືອຂ່າຍ neural ທີ່ວາງໄວ້ກ່ອນຫນ້ານີ້ພາຍໃນ container, ຫຼື shell ຄໍາສັ່ງສໍາລັບການ debugging ແລະຕິດຕາມກວດກາການດໍາເນີນງານຂອງ container ໄດ້:

ສະຄຣິບເພື່ອເປີດກ່ອງບັນຈຸ

#!/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}

ຖ້າ script bash ນີ້ຖືກແລ່ນໂດຍບໍ່ມີພາລາມິເຕີ, script ຈະຖືກເອີ້ນພາຍໃນ container train_nn.R ດ້ວຍຄ່າເລີ່ມຕົ້ນ; ຖ້າການໂຕ້ຖຽງຕໍາແຫນ່ງທໍາອິດແມ່ນ "bash", ຫຼັງຈາກນັ້ນ, ບັນຈຸຈະເລີ່ມຕົ້ນການໂຕ້ຕອບກັບແກະຄໍາສັ່ງ. ໃນກໍລະນີອື່ນໆ, ມູນຄ່າຂອງການໂຕ້ຖຽງຕໍາແຫນ່ງແມ່ນທົດແທນ: CMD="Rscript /app/train_nn.R $@".

ມັນເປັນມູນຄ່າທີ່ສັງເກດວ່າໄດເລກະທໍລີທີ່ມີຂໍ້ມູນແຫຼ່ງແລະຖານຂໍ້ມູນ, ເຊັ່ນດຽວກັນກັບໄດເລກະທໍລີສໍາລັບການປະຫຍັດຕົວແບບທີ່ໄດ້ຮັບການຝຶກອົບຮົມ, ຖືກຕິດຕັ້ງຢູ່ໃນຖັງຈາກລະບົບໂຮດ, ເຊິ່ງຊ່ວຍໃຫ້ທ່ານສາມາດເຂົ້າຫາຜົນໄດ້ຮັບຂອງສະຄິບໄດ້ໂດຍບໍ່ມີການຫມູນໃຊ້ທີ່ບໍ່ຈໍາເປັນ.

7. ການໃຊ້ GPU ຫຼາຍອັນໃນ Google Cloud

ຫນຶ່ງໃນລັກສະນະຂອງການແຂ່ງຂັນແມ່ນຂໍ້ມູນທີ່ບໍ່ມີສຽງຫຼາຍ (ເບິ່ງຮູບຫົວຂໍ້, ຢືມຈາກ @Leigh.plt ຈາກ ODS slack). ຊຸດໃຫຍ່ຊ່ວຍຕໍ່ສູ້ກັບສິ່ງນີ້, ແລະຫຼັງຈາກການທົດລອງໃນ PC ທີ່ມີ 1 GPU, ພວກເຮົາໄດ້ຕັດສິນໃຈສ້າງແບບຈໍາລອງການຝຶກອົບຮົມໃນຫຼາຍໆ GPUs ໃນຄລາວ. ໃຊ້ GoogleCloud (ຄູ່ມືທີ່ດີກ່ຽວກັບພື້ນຖານ) ເນື່ອງຈາກການຄັດເລືອກຂະຫນາດໃຫຍ່ຂອງການຕັ້ງຄ່າທີ່ມີຢູ່, ລາຄາທີ່ສົມເຫດສົມຜົນແລະ $ 300 ໂບນັດ. ດ້ວຍຄວາມໂລບມາກ, ຂ້າພະເຈົ້າໄດ້ສັ່ງຕົວຢ່າງ 4xV100 ທີ່ມີ SSD ແລະ RAM ໂຕນ, ແລະນັ້ນແມ່ນຄວາມຜິດພາດອັນໃຫຍ່ຫຼວງ. ເຄື່ອງຈັກດັ່ງກ່າວກິນເງິນຢ່າງໄວວາ; ທ່ານສາມາດທໍາລາຍການທົດລອງໄດ້ໂດຍບໍ່ມີການພິສູດ. ສໍາລັບການສຶກສາ, ມັນດີກວ່າທີ່ຈະເອົາ 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
  )
})

ຫຼັງຈາກນັ້ນ, ຮູບແບບທີ່ບໍ່ໄດ້ລວບລວມ (ນີ້ແມ່ນສໍາຄັນ) ຖືກຄັດລອກໄປຫາຈໍານວນ GPUs ທີ່ມີຢູ່, ແລະພຽງແຕ່ຫຼັງຈາກນັ້ນມັນຖືກລວບລວມ:

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 ບໍ່ມີຟັງຊັນທີ່ກຽມພ້ອມສໍາລັບການຊອກຫາອັດຕະໂນມັດສໍາລັບອັດຕາການຮຽນຮູ້ທີ່ດີທີ່ສຸດ (analogue lr_finder ໃນຫໍສະມຸດ fast.ai); ດ້ວຍຄວາມພະຍາຍາມບາງຢ່າງ, ມັນເປັນໄປໄດ້ທີ່ຈະສົ່ງການປະຕິບັດຂອງພາກສ່ວນທີສາມໄປຫາ R, ສໍາລັບຕົວຢ່າງ, ນີ້;
• ເປັນຜົນມາຈາກຈຸດທີ່ຜ່ານມາ, ມັນບໍ່ສາມາດເລືອກຄວາມໄວການຝຶກອົບຮົມທີ່ຖືກຕ້ອງໃນເວລາທີ່ໃຊ້ GPUs ຫຼາຍ;
• ມີການຂາດສະຖາປັດຕະຍະກໍາເຄືອຂ່າຍ neural ທີ່ທັນສະໄຫມ, ໂດຍສະເພາະແມ່ນການຝຶກອົບຮົມເບື້ອງຕົ້ນໃນ imagenet;
• ບໍ່​ມີ​ນະ​ໂຍ​ບາຍ​ວົງ​ຈອນ​ໃດ​ຫນຶ່ງ​ແລະ​ອັດ​ຕາ​ການ​ຮຽນ​ຮູ້​ຈໍາ​ແນກ (ການ​ເຊື່ອມ​ສານ cosine ແມ່ນ​ຢູ່​ໃນ​ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ​ຂອງ​ພວກ​ເຮົາ​ ປະຕິບັດ, ຂອບ​ໃຈ ສະກີແດນ).

ສິ່ງທີ່ເປັນປະໂຫຍດທີ່ໄດ້ຮຽນຮູ້ຈາກການແຂ່ງຂັນນີ້:

• ໃນຮາດແວທີ່ມີພະລັງງານຕ່ໍາ, ທ່ານສາມາດເຮັດວຽກກັບປະລິມານຂໍ້ມູນທີ່ເຫມາະສົມ (ຫຼາຍຄັ້ງຂອງ RAM) ໂດຍບໍ່ມີຄວາມເຈັບປວດ. ຖົງ​ຢາງ ຕາຕະລາງ ຊ່ວຍປະຢັດຄວາມຊົງຈໍາເນື່ອງຈາກການດັດແປງຕາຕະລາງ, ເຊິ່ງຫຼີກເວັ້ນການຄັດລອກພວກມັນ, ແລະເມື່ອຖືກນໍາໃຊ້ຢ່າງຖືກຕ້ອງ, ຄວາມສາມາດຂອງມັນເກືອບສະເຫມີສະແດງໃຫ້ເຫັນເຖິງຄວາມໄວສູງສຸດໃນບັນດາເຄື່ອງມືທັງຫມົດທີ່ຮູ້ຈັກກັບພວກເຮົາສໍາລັບພາສາສະຄິບ. ການປະຫຍັດຂໍ້ມູນໃນຖານຂໍ້ມູນຊ່ວຍໃຫ້ທ່ານ, ໃນຫຼາຍໆກໍລະນີ, ບໍ່ຕ້ອງຄິດກ່ຽວກັບຄວາມຕ້ອງການທີ່ຈະບີບຊຸດຂໍ້ມູນທັງຫມົດເຂົ້າໄປໃນ RAM.
• ຟັງຊັນຊ້າໃນ R ສາມາດຖືກແທນທີ່ດ້ວຍໄວໃນ C++ ໂດຍໃຊ້ຊຸດ Rcpp. ຖ້າ​ຫາກ​ວ່າ​ນອກ​ເຫນືອ​ໄປ​ຈາກ​ການ​ນໍາ​ໃຊ້​ RcppThread ຫຼື RcppParallel, ພວກເຮົາໄດ້ຮັບການປະຕິບັດຫຼາຍກະທູ້ຂ້າມເວທີ, ດັ່ງນັ້ນບໍ່ຈໍາເປັນຕ້ອງມີການຂະຫນານລະຫັດຢູ່ໃນລະດັບ R.
• ຊຸດ Rcpp ສາມາດຖືກນໍາໃຊ້ໂດຍບໍ່ມີຄວາມຮູ້ທີ່ຮ້າຍແຮງຂອງ C ++, ຕໍາ່ສຸດທີ່ທີ່ກໍານົດໄວ້ແມ່ນໄດ້ລະບຸໄວ້ ທີ່ນີ້. ໄຟລ໌ຫົວສໍາລັບຈໍານວນຂອງຫ້ອງສະຫມຸດ C ເຢັນເຊັ່ນ xtensor ມີຢູ່ໃນ CRAN, ນັ້ນແມ່ນ, ໂຄງສ້າງພື້ນຖານໄດ້ຖືກສ້າງຕັ້ງຂຶ້ນສໍາລັບການຈັດຕັ້ງປະຕິບັດໂຄງການທີ່ປະສົມປະສານລະຫັດ C ++ ທີ່ມີປະສິດຕິພາບສູງທີ່ກຽມພ້ອມເຂົ້າໄປໃນ R. ຄວາມສະດວກສະບາຍເພີ່ມເຕີມແມ່ນການເນັ້ນ syntax ແລະຕົວວິເຄາະລະຫັດ C++ ຄົງທີ່ໃນ RStudio.
• docopt ອະນຸຍາດໃຫ້ທ່ານດໍາເນີນການ scripts ດ້ວຍຕົນເອງທີ່ມີພາລາມິເຕີ. ນີ້ແມ່ນສະດວກສໍາລັບການນໍາໃຊ້ໃນເຄື່ອງແມ່ຂ່າຍຫ່າງໄກສອກຫຼີກ, incl. ພາຍໃຕ້ docker. ໃນ RStudio, ມັນບໍ່ສະດວກທີ່ຈະດໍາເນີນການທົດລອງຫຼາຍຊົ່ວໂມງກັບເຄືອຂ່າຍ neural ການຝຶກອົບຮົມ, ແລະການຕິດຕັ້ງ IDE ໃນເຄື່ອງແມ່ຂ່າຍຂອງຕົວມັນເອງແມ່ນບໍ່ສົມເຫດສົມຜົນສະເຫມີ.
• Docker ຮັບປະກັນການເຄື່ອນທີ່ຂອງລະຫັດແລະການແຜ່ພັນຂອງຜົນໄດ້ຮັບລະຫວ່າງຜູ້ພັດທະນາທີ່ມີລຸ້ນ OS ແລະຫ້ອງສະຫມຸດທີ່ແຕກຕ່າງກັນ, ເຊັ່ນດຽວກັນກັບຄວາມງ່າຍໃນການປະຕິບັດໃນເຄື່ອງແມ່ຂ່າຍ. ທ່ານສາມາດເປີດທໍ່ການຝຶກອົບຮົມທັງຫມົດດ້ວຍຄໍາສັ່ງດຽວ.
• Google Cloud ເປັນວິທີທີ່ໃຊ້ງົບປະມານເພື່ອທົດລອງໃຊ້ຮາດແວລາຄາແພງ, ແຕ່ທ່ານຕ້ອງເລືອກການຕັ້ງຄ່າຢ່າງລະມັດລະວັງ.
• ການ​ວັດ​ແທກ​ຄວາມ​ໄວ​ຂອງ​ລະ​ຫັດ​ສ່ວນ​ບຸກ​ຄົນ​ແມ່ນ​ເປັນ​ປະ​ໂຫຍດ​ຫຼາຍ​, ໂດຍ​ສະ​ເພາະ​ແມ່ນ​ໃນ​ເວ​ລາ​ທີ່​ການ​ປະ​ສົມ R ແລະ C ++​, ແລະ​ກັບ​ຊຸດ​. bench - ຍັງ​ງ່າຍ​ຫຼາຍ​.

ໂດຍລວມແລ້ວ, ປະສົບການນີ້ແມ່ນໃຫ້ລາງວັນຫຼາຍ ແລະພວກເຮົາສືບຕໍ່ເຮັດວຽກເພື່ອແກ້ໄຂບາງບັນຫາທີ່ຍົກຂຶ້ນມາ.

ແຫຼ່ງຂໍ້ມູນ: www.habr.com