Quick Draw Doodle Recognition: როგორ დავუმეგობრდეთ R, C++ და ნერვულ ქსელებს

ჰეი ჰაბრ!

გასულ შემოდგომაზე კაგლმა უმასპინძლა კონკურსს ხელით დახატული სურათების კლასიფიკაციისთვის, Quick Draw Doodle Recognition, რომელშიც, სხვათა შორის, R-მეცნიერთა ჯგუფმა მიიღო მონაწილეობა: არტემ კლევცოვა, ფილიპა მენეჯერი и ანდრეი ოგურცოვი. ჩვენ დეტალურად არ აღვწერთ კონკურსს, ეს უკვე გაკეთდა ბოლო პუბლიკაცია.

ამჯერად მედლების მეურნეობამ არ გაამართლა, მაგრამ დიდი ღირებული გამოცდილება დაგროვდა, ამიტომ მსურს საზოგადოებას ვუთხრა რამდენიმე ყველაზე საინტერესო და სასარგებლო რამ კაგლეზე და ყოველდღიურ საქმიანობაში. განხილულ თემებს შორის: რთული ცხოვრება გარეშე OpenCV, JSON პარსინგი (ეს მაგალითები განიხილავს C++ კოდის ინტეგრაციას სკრიპტებში ან R-ში პაკეტებში, გამოყენებით Rcpp), სკრიპტების პარამეტრიზაცია და საბოლოო ამოხსნის დოკერიზაცია. შეტყობინებებიდან ყველა კოდი შესასრულებლად შესაფერისი ფორმით ხელმისაწვდომია საცავები.

შინაარსი:

1. ეფექტურად ჩატვირთეთ მონაცემები CSV-დან MonetDB-ში
2. პარტიების მომზადება
3. იტერატორები პარტიების მონაცემთა ბაზიდან გადმოტვირთვისთვის
4. მოდელის არქიტექტურის შერჩევა
5. სკრიპტის პარამეტრიზაცია
6. სკრიპტების დოკერიზაცია
7. Google Cloud-ზე მრავალი GPU-ს გამოყენება
8. იმის ნაცვლად, რომ დასკვნა

1. ეფექტურად ჩატვირთეთ მონაცემები CSV-დან MonetDB მონაცემთა ბაზაში

ამ კონკურსის მონაცემები მოწოდებულია არა მზა სურათების სახით, არამედ 340 CSV ფაილის სახით (თითო ფაილი თითოეულ კლასზე), რომელიც შეიცავს JSON-ებს წერტილოვანი კოორდინატებით. ამ წერტილების ხაზებთან შეერთებით მივიღებთ საბოლოო სურათს 256x256 პიქსელის ზომის. ასევე თითოეული ჩანაწერისთვის არის ეტიკეტი, რომელიც მიუთითებს, სწორად იქნა თუ არა სურათის ამოცნობა კლასიფიკატორის მიერ, რომელიც გამოიყენება მონაცემთა ნაკრების შეგროვების დროს, სურათის ავტორის საცხოვრებელი ქვეყნის ორასოიანი კოდი, უნიკალური იდენტიფიკატორი, დროის შტამპი. და კლასის სახელი, რომელიც შეესაბამება ფაილის სახელს. ორიგინალური მონაცემების გამარტივებული ვერსია იწონის 7.4 GB არქივში და დაახლოებით 20 GB შეფუთვის შემდეგ, სრული მონაცემები 240 GB-ს შეადგენს. ორგანიზატორებმა დარწმუნდნენ, რომ ორივე ვერსიაში ერთი და იგივე ნახატების რეპროდუცირება მოხდა, რაც იმას ნიშნავს, რომ სრული ვერსია ზედმეტი იყო. ნებისმიერ შემთხვევაში, 50 მილიონი სურათის გრაფიკულ ფაილებში ან მასივების სახით შენახვა მაშინვე წამგებად ჩაითვალა და ჩვენ გადავწყვიტეთ შეგვეერთებინა ყველა CSV ფაილი არქივიდან. train_simplified.zip მონაცემთა ბაზაში საჭირო ზომის სურათების შემდგომი გენერირებით თითოეული პარტიისთვის.

კარგად დადასტურებული სისტემა აირჩიეს 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 in R არ მუშაობს სწორად არქივიდან რამდენიმე ფაილთან, ამიტომ ჩვენ გამოვიყენეთ სისტემა unzip (პარამეტრის გამოყენებით getOption("unzip")).

მონაცემთა ბაზაში ჩაწერის ფუნქცია

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

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

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

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

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

  return(invisible(TRUE))
}

თუ თქვენ გჭირდებათ ცხრილის ტრანსფორმაცია მონაცემთა ბაზაში ჩაწერამდე, საკმარისია არგუმენტში ჩაბარება preprocess ფუნქცია, რომელიც გარდაქმნის მონაცემებს.

მონაცემთა ბაზაში მონაცემების თანმიმდევრული ჩატვირთვის კოდი:

მონაცემთა ბაზაში ჩაწერა

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

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

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

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

მონაცემთა ჩატვირთვის დრო შეიძლება განსხვავდებოდეს გამოყენებული დისკის სიჩქარის მახასიათებლების მიხედვით. ჩვენს შემთხვევაში, ერთი SSD-ში ან ფლეშ დრაივიდან (წყარო ფაილი) SSD-მდე (DB) კითხვასა და ჩაწერას 10 წუთზე ნაკლებ დრო სჭირდება.

კიდევ რამდენიმე წამი სჭირდება სვეტის შექმნას მთელი კლასის ლეიბლით და ინდექსის სვეტით (ORDERED INDEX) სტრიქონების ნომრებით, რომლებითაც იქნება დაკვირვების ნიმუშის აღება პარტიების შექმნისას:

დამატებითი სვეტების და ინდექსის შექმნა

message("Generate lables")
invisible(DBI::dbExecute(con, "ALTER TABLE doodles ADD label_int int"))
invisible(DBI::dbExecute(con, "UPDATE doodles SET label_int = dense_rank() OVER (ORDER BY word) - 1"))

message("Generate row numbers")
invisible(DBI::dbExecute(con, "ALTER TABLE doodles ADD id serial"))
invisible(DBI::dbExecute(con, "CREATE ORDERED INDEX doodles_id_ord_idx ON doodles(id)"))

ფრენის დროს ჯგუფის შექმნის პრობლემის გადასაჭრელად, ჩვენ გვჭირდებოდა მაგიდიდან შემთხვევითი რიგების ამოღების მაქსიმალური სიჩქარის მიღწევა. doodles. ამისთვის გამოვიყენეთ 3 ხრიკი. პირველი იყო იმ ტიპის განზომილების შემცირება, რომელიც ინახავს დაკვირვების ID-ს. ორიგინალურ მონაცემთა ნაკრებში ID-ის შესანახად საჭირო ტიპი არის bigint, მაგრამ დაკვირვებების რაოდენობა შესაძლებელს ხდის მათი იდენტიფიკატორების, რიგითი რიცხვის ტოლი, ტიპში მორგებას int. ამ შემთხვევაში ძებნა ბევრად უფრო სწრაფია. მეორე ხრიკი იყო გამოყენება ORDERED INDEX - ამ გადაწყვეტილებამდე მივედით ემპირიულად, ყველა არსებულის გავლის შემდეგ პარამეტრები. მესამე იყო პარამეტრიზებული მოთხოვნების გამოყენება. მეთოდის არსი არის ბრძანების ერთხელ შესრულება PREPARE მომზადებული გამონათქვამის შემდგომი გამოყენებით იმავე ტიპის მოთხოვნების თაიგულის შექმნისას, მაგრამ სინამდვილეში არსებობს უპირატესობა მარტივთან შედარებით SELECT აღმოჩნდა სტატისტიკური ცდომილების ფარგლებში.

მონაცემთა ატვირთვის პროცესი მოიხმარს არაუმეტეს 450 MB ოპერატიული მეხსიერება. ანუ, აღწერილი მიდგომა საშუალებას გაძლევთ გადაიტანოთ მონაცემთა ნაკრები, რომელიც იწონის ათობით გიგაბაიტს, თითქმის ნებისმიერ საბიუჯეტო აპარატურაზე, მათ შორის ზოგიერთ ერთბორტ მოწყობილობაზე, რაც საკმაოდ მაგარია.

რჩება მხოლოდ (შემთხვევითი) მონაცემების მოპოვების სიჩქარის გაზომვა და სკალირების შეფასება სხვადასხვა ზომის პარტიების შერჩევისას:

მონაცემთა ბაზის საორიენტაციო ნიშანი

library(ggplot2)

set.seed(0)
# Подключение к базе данных
con <- DBI::dbConnect(MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))

# Функция для подготовки запроса на стороне сервера
prep_sql <- function(batch_size) {
  sql <- sprintf("PREPARE SELECT id FROM doodles WHERE id IN (%s)",
                 paste(rep("?", batch_size), collapse = ","))
  res <- DBI::dbSendQuery(con, sql)
  return(res)
}

# Функция для извлечения данных
fetch_data <- function(rs, batch_size) {
  ids <- sample(seq_len(n), batch_size)
  res <- DBI::dbFetch(DBI::dbBind(rs, as.list(ids)))
  return(res)
}

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

#   batch_size      min   median      max `itr/sec` total_time n_itr
#        <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
# 1         16   23.6ms  54.02ms  93.43ms     18.8        2.6s    49
# 2         32     38ms  84.83ms 151.55ms     11.4       4.29s    49
# 3         64   63.3ms 175.54ms 248.94ms     5.85       8.54s    50
# 4        128   83.2ms 341.52ms 496.24ms     3.00      16.69s    50
# 5        256  232.8ms 653.21ms 847.44ms     1.58      31.66s    50
# 6        512  784.6ms    1.41s    1.98s     0.740       1.1m    49
# 7       1024  681.7ms    2.72s    4.06s     0.377      2.16m    49

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

DBI::dbDisconnect(con, shutdown = TRUE)

2. პარტიების მომზადება

მთელი ჯგუფის მომზადების პროცესი შედგება შემდეგი ნაბიჯებისგან:

1. რამდენიმე JSON-ის გარჩევა, რომლებიც შეიცავს სტრიქონების ვექტორებს წერტილების კოორდინატებით.
2. საჭირო ზომის სურათზე (მაგალითად, 256×256 ან 128×128) წერტილების კოორდინატებზე დაყრდნობით ფერადი ხაზების დახატვა.
3. მიღებული სურათების ტენზორად გადაქცევა.

პითონის ბირთვებს შორის კონკურსის ფარგლებში, პრობლემა მოგვარდა ძირითადად გამოყენებით OpenCV. ერთ-ერთი ყველაზე მარტივი და აშკარა ანალოგი R-ში ასე გამოიყურება:

JSON-ის ტენსორში კონვერტაციის განხორციელება 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-ში). ეს ფაილი შემდეგ იკითხება სამგანზომილებიანი მასივის სახით 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.

პრობლემის გადასაჭრელად გამოყენებული იქნა შემდეგი პაკეტები და ბიბლიოთეკები:

1. OpenCV სურათებთან მუშაობისა და ხაზების დახატვისთვის. გამოყენებულია წინასწარ დაინსტალირებული სისტემის ბიბლიოთეკები და სათაურის ფაილები, ასევე დინამიური ლინკები.

2. xtensor მრავალგანზომილებიან მასივებთან და ტენსორებთან მუშაობისთვის. ჩვენ გამოვიყენეთ სათაურის ფაილები, რომლებიც შედის ამავე სახელწოდების R პაკეტში. ბიბლიოთეკა საშუალებას გაძლევთ იმუშაოთ მრავალგანზომილებიან მასივებთან, როგორც მწკრივის ძირითადი, ასევე სვეტის ძირითადი თანმიმდევრობით.

3. ნჯსონი JSON გასაანალიზებლად. ეს ბიბლიოთეკა გამოიყენება xtensor ავტომატურად, თუ ის არის პროექტში.

4. RcppThread JSON-დან ვექტორის მრავალსართულიანი დამუშავების ორგანიზებისთვის. გამოიყენა ამ პაკეტით მოწოდებული სათაურის ფაილები. უფრო პოპულარულიდან Rcppპარალელური პაკეტს, სხვა საკითხებთან ერთად, აქვს ჩაშენებული მარყუჟის შეწყვეტის მექანიზმი.

აღსანიშნავია, რომ xtensor ღვთიური ნიჭი აღმოჩნდა: გარდა იმისა, რომ მას აქვს ფართო ფუნქციონირება და მაღალი შესრულება, მისი დეველოპერები საკმაოდ საპასუხო აღმოჩნდნენ და სწრაფად და დეტალურად უპასუხეს კითხვებს. მათი დახმარებით შესაძლებელი გახდა OpenCV მატრიცების ტრანსფორმაციები xtensor ტენზორებად, ისევე როგორც 3-განზომილებიანი გამოსახულების ტენსორების გაერთიანების გზა სწორი განზომილების 4-განზომილებიან ტენზორში (თავად პარტია).

მასალები Rcpp, xtensor და RcppThread-ის შესასწავლად

https://thecoatlessprofessor.com/programming/unofficial-rcpp-api-documentation

https://docs.opencv.org/4.0.1/d7/dbd/group__imgproc.html

https://xtensor.readthedocs.io/en/latest/

https://xtensor.readthedocs.io/en/latest/file_loading.html#loading-json-data-into-xtensor

https://cran.r-project.org/web/packages/RcppThread/vignettes/RcppThread-vignette.pdf

ფაილების შედგენისთვის, რომლებიც იყენებენ სისტემურ ფაილებს და დინამიურ კავშირს სისტემაში დაყენებულ ბიბლიოთეკებთან, ჩვენ გამოვიყენეთ პაკეტში დანერგილი დანამატის მექანიზმი. Rcpp. ბილიკებისა და დროშების ავტომატურად მოსაძებნად, ჩვენ გამოვიყენეთ პოპულარული Linux პროგრამა pkg-config.

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

მოდულის მუშაობის შედეგად, შედგენის პროცესში შეიცვლება შემდეგი მნიშვნელობები:

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

JSON-ის ტენსორად გადაქცევის განხორციელება 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 - შაბლონური ფუნქცია გამოსახულების მატრიცის გარდაქმნისთვის (cv::Mat) ტენზორზე xt::xtensor;

• parse_json — ფუნქცია აანალიზებს JSON სტრიქონს, ამოიღებს წერტილების კოორდინატებს და ათავსებს მათ ვექტორში;

• ocv_draw_lines — წარმოქმნილი წერტილების ვექტორიდან ხაზავს მრავალფეროვან ხაზებს;

• process — აერთიანებს ზემოხსენებულ ფუნქციებს და ასევე ამატებს მიღებული გამოსახულების მასშტაბირების შესაძლებლობას;

• cpp_process_json_str - შეფუთვა ფუნქციაზე process, რომელიც ახდენს შედეგის ექსპორტს R-ობიექტში (მრავალგანზომილებიანი მასივი);

• cpp_process_json_vector - შეფუთვა ფუნქციაზე cpp_process_json_str, რომელიც საშუალებას გაძლევთ დაამუშავოთ სტრიქონი ვექტორი მრავალძაფის რეჟიმში.

მრავალფერადი ხაზების დასახატად გამოყენებული იქნა HSV ფერის მოდელი, რასაც მოჰყვა კონვერტაცია RGB-ზე. მოდით შევამოწმოთ შედეგი:

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

განხორციელებების სიჩქარის შედარება R და C++-ში

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

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

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

res_bench[, cols]

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

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

როგორც ხედავთ, სიჩქარის მატება ძალიან მნიშვნელოვანი აღმოჩნდა და R კოდის პარალელიზებით C++ კოდის დაჭერა შეუძლებელია.

3. იტერატორები პარტიების ბაზიდან გადმოტვირთვისთვის

R-ს აქვს დამსახურებული რეპუტაცია მონაცემთა დამუშავებისთვის, რომელიც ჯდება RAM-ში, ხოლო Python-ს უფრო მეტად ახასიათებს მონაცემთა განმეორებითი დამუშავება, რაც საშუალებას გაძლევთ მარტივად და ბუნებრივად განახორციელოთ გარე გამოთვლები (გამოთვლები გარე მეხსიერების გამოყენებით). ჩვენთვის კლასიკური და შესაბამისი მაგალითი აღწერილი პრობლემის კონტექსტში არის ღრმა ნერვული ქსელები, რომლებიც მომზადებულია გრადიენტული დაღმართის მეთოდით, გრადიენტის მიახლოებით თითოეულ საფეხურზე დაკვირვების მცირე ნაწილის ან მინი-სერიის გამოყენებით.

Python-ში დაწერილ ღრმა სწავლების ჩარჩოებს აქვთ სპეციალური კლასები, რომლებიც ახორციელებენ იტერატორებს მონაცემებზე დაყრდნობით: ცხრილები, სურათები საქაღალდეებში, ორობითი ფორმატები და ა.შ. შეგიძლიათ გამოიყენოთ მზა ვარიანტები ან დაწეროთ საკუთარი კონკრეტული ამოცანებისთვის. R-ში შეგვიძლია ვისარგებლოთ პითონის ბიბლიოთეკის ყველა მახასიათებლით კერას თავისი სხვადასხვა ბექენდებით ამავე სახელწოდების პაკეტის გამოყენებით, რომელიც თავის მხრივ მუშაობს პაკეტის თავზე ბადეები. ეს უკანასკნელი იმსახურებს ცალკე ვრცელ სტატიას; ის არა მხოლოდ საშუალებას გაძლევთ გაუშვათ პითონის კოდი R-დან, არამედ საშუალებას გაძლევთ გადაიტანოთ ობიექტები R და Python სესიებს შორის, ავტომატურად შეასრულოთ ყველა საჭირო ტიპის კონვერტაცია.

ჩვენ გავთავისუფლდით ყველა მონაცემის RAM-ში შენახვის აუცილებლობაზე MonetDBLite-ის გამოყენებით, ყველა „ნერვული ქსელის“ სამუშაო შესრულდება ორიგინალური კოდით Python-ში, ჩვენ უბრალოდ უნდა დავწეროთ იტერატორი მონაცემებზე, რადგან მზად არაფერია. ასეთი სიტუაციისთვის ან R ან Python-ში. მას არსებითად მხოლოდ ორი მოთხოვნა აქვს: მან უნდა დააბრუნოს სერიები გაუთავებელ ციკლში და შეინახოს მისი მდგომარეობა გამეორებებს შორის (ეს უკანასკნელი R-ში ხორციელდება უმარტივესი გზით დახურვის გამოყენებით). ადრე საჭირო იყო R მასივების მკაფიოდ გადაქცევა იტერატორის შიგნით, მაგრამ პაკეტის ამჟამინდელი ვერსია კერას თვითონ აკეთებს.

ტრენინგისა და ვალიდაციის მონაცემების განმეორებადი აღმოჩნდა შემდეგი:

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

ფუნქცია შესაყვანად იღებს ცვლადს, რომელიც დაკავშირებულია მონაცემთა ბაზასთან, გამოყენებული ხაზების რაოდენობა, კლასების რაოდენობა, ჯგუფის ზომა, მასშტაბი (scale = 1 შეესაბამება 256x256 პიქსელიანი სურათების გადაცემას, scale = 0.5 - 128x128 პიქსელი), ფერის მაჩვენებელი (color = FALSE აკონკრეტებს რენდერირებას ნაცრისფერ ფერებში გამოყენებისას color = TRUE თითოეული სტრიქონი შედგენილია ახალ ფერში) და წინასწარი დამუშავების ინდიკატორი ქსელებისთვის, რომლებიც წინასწარ მომზადებულნი არიან imagenet-ზე. ეს უკანასკნელი საჭიროა იმისათვის, რომ მოხდეს პიქსელის მნიშვნელობების მასშტაბირება [0, 1] ინტერვალიდან [-1, 1] ინტერვალამდე, რომელიც გამოიყენებოდა მიწოდების ვარჯიშის დროს. კერას მოდელები.

გარე ფუნქცია შეიცავს არგუმენტის ტიპის შემოწმებას, ცხრილს 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 და მოდიფიკაცია ბმულის საშუალებით - ამ პაკეტის "ჩიპების" გარეშე მონაცემები. მაგიდა საკმაოდ რთული წარმოსადგენია რ-ში რაიმე მნიშვნელოვანი მოცულობის მონაცემებთან ეფექტურად მუშაობა.

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-ზე გადატანით (ჩვენი ამოცანისთვის საკმარისია 32 გბ). Linux-ში დანაყოფი დამონტაჟებულია ნაგულისხმევად /dev/shm, იკავებს RAM-ის ტევადობის ნახევარს. მეტის მონიშვნა შეგიძლიათ რედაქტირებით /etc/fstabრომ მიიღოთ მსგავსი ჩანაწერი tmpfs /dev/shm tmpfs defaults,size=25g 0 0. დარწმუნდით, რომ გადატვირთეთ და შეამოწმეთ შედეგი ბრძანების გაშვებით df -h.

ტესტის მონაცემების გამეორება ბევრად უფრო მარტივია, რადგან ტესტის მონაცემთა ნაკრები მთლიანად ჯდება 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, რომლის თავისებურებები განხილულია ქ ეს შეტყობინება. შედის სტანდარტულად კერას და, შესაბამისად, ხელმისაწვდომია 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)

ახლა ძნელი არ არის უნივერსალური ფუნქციის დაწერა რომელიმე მოწოდებულის მისაღებად კერას imagenet-ზე მომზადებული წონებით ან მის გარეშე მოდელები:

მზა არქიტექტურების ჩატვირთვის ფუნქცია

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

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

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

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

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

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

  return(model)
}

ერთარხიანი სურათების გამოყენებისას არ გამოიყენება წინასწარ მომზადებული წონა. ეს შეიძლება გამოსწორდეს: ფუნქციის გამოყენებით get_weights() მიიღეთ მოდელის წონა R მასივების სიის სახით, შეცვალეთ ამ სიის პირველი ელემენტის განზომილება (ერთი ფერადი არხის აღებით ან სამივე საშუალოდ) და შემდეგ ჩატვირთეთ წონა მოდელში ფუნქციით. set_weights(). ჩვენ არასდროს დავამატეთ ეს ფუნქციონირება, რადგან ამ ეტაპზე უკვე ნათელი იყო, რომ უფრო პროდუქტიული იყო ფერად სურათებთან მუშაობა.

ჩვენ ჩავატარეთ ექსპერიმენტების უმეტესობა mobilenet ვერსიების 1 და 2, ისევე როგორც resnet34 გამოყენებით. უფრო თანამედროვე არქიტექტურებმა, როგორიცაა SE-ResNeXt, კარგად ითამაშეს ამ კონკურსში. სამწუხაროდ, ჩვენ ხელთ არ გვქონდა მზა იმპლემენტაციები და არც ჩვენი დაგვიწერია (მაგრამ აუცილებლად დავწერთ).

5. სკრიპტების პარამეტრიზაცია

მოხერხებულობისთვის, ტრენინგის დაწყების ყველა კოდი შეიქმნა, როგორც ერთი სკრიპტი, პარამეტრირებული გამოყენებით დოკოპტი შემდეგნაირად:

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

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

პაკეტი დოკოპტი წარმოადგენს განხორციელებას http://docopt.org/ R.-ისთვის მისი დახმარებით სკრიპტები გაშვებულია მარტივი ბრძანებებით, როგორიცაა Rscript bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db ან ./bin/train_nn.R -m resnet50 -c -d /home/andrey/doodle_db, თუ ფაილი train_nn.R არის შესრულებადი (ეს ბრძანება დაიწყებს მოდელის სწავლებას resnet50 128x128 პიქსელის ზომის სამფეროვან სურათზე მონაცემთა ბაზა უნდა იყოს განთავსებული საქაღალდეში /home/andrey/doodle_db). თქვენ შეგიძლიათ დაამატოთ სწავლის სიჩქარე, ოპტიმიზატორის ტიპი და ნებისმიერი სხვა კონფიგურირებადი პარამეტრი სიაში. პუბლიკაციის მომზადების პროცესში აღმოჩნდა, რომ არქიტექტურა mobilenet_v2 მიმდინარე ვერსიიდან კერას R გამოყენებაში არ უნდა R პაკეტში გაუთვალისწინებელი ცვლილებების გამო, ველოდებით მის გამოსწორებას.

ამ მიდგომამ შესაძლებელი გახადა მნიშვნელოვნად დაჩქარებულიყო ექსპერიმენტები სხვადასხვა მოდელებთან შედარებით RStudio-ში სკრიპტების უფრო ტრადიციულ გაშვებასთან შედარებით (ჩვენ აღვნიშნავთ პაკეტს, როგორც შესაძლო ალტერნატივას ტფრუნს). მაგრამ მთავარი უპირატესობა არის Docker-ში ან უბრალოდ სერვერზე სკრიპტების გაშვების მარტივად მართვის შესაძლებლობა, ამისათვის RStudio-ს დაყენების გარეშე.

6. სკრიპტების დოკერიზაცია

ჩვენ გამოვიყენეთ Docker გარემოს პორტაბელურობის უზრუნველსაყოფად გუნდის წევრებს შორის ტრენინგის მოდელებისთვის და ღრუბელში სწრაფი განლაგებისთვის. თქვენ შეგიძლიათ დაიწყოთ R პროგრამისტისთვის შედარებით უჩვეულო ამ ხელსაწყოს გაცნობა ამ პუბლიკაციების სერია ან ვიდეო კურსი.

Docker გაძლევთ საშუალებას შექმნათ თქვენი საკუთარი სურათები ნულიდან და გამოიყენოთ სხვა სურათები, როგორც საფუძველი საკუთარის შესაქმნელად. ხელმისაწვდომი ვარიანტების გაანალიზებისას მივედით დასკვნამდე, რომ NVIDIA, CUDA+cuDNN დრაივერების და Python ბიბლიოთეკების დაყენება სურათის საკმაოდ მოცულობითი ნაწილია და გადავწყვიტეთ საფუძვლად აგვეღო ოფიციალური სურათი. tensorflow/tensorflow:1.12.0-gpu, იქ დაამატეთ საჭირო R პაკეტები.

საბოლოო დოკერის ფაილი ასე გამოიყურებოდა:

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

მოხერხებულობისთვის გამოყენებული პაკეტები მოთავსდა ცვლადებში; დაწერილი სკრიპტების უმეტესი ნაწილი კოპირებულია კონტეინერებში შეკრების დროს. ჩვენ ასევე შევცვალეთ ბრძანების ჭურვი /bin/bash შინაარსის მარტივად გამოყენებისთვის /etc/os-release. ამან თავიდან აიცილა OS-ის ვერსიის კოდში მითითების აუცილებლობა.

გარდა ამისა, დაიწერა პატარა bash სკრიპტი, რომელიც საშუალებას გაძლევთ გაუშვათ კონტეინერი სხვადასხვა ბრძანებებით. მაგალითად, ეს შეიძლება იყოს სკრიპტები ნერვული ქსელების მომზადებისთვის, რომლებიც ადრე იყო განთავსებული კონტეინერის შიგნით, ან ბრძანების გარსი კონტეინერის მუშაობის გამართვისა და მონიტორინგისთვის:

სკრიპტი კონტეინერის გასაშვებად

#!/bin/sh

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

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

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

თუ ეს bash სკრიპტი გაშვებულია პარამეტრების გარეშე, სკრიპტი გამოიძახება კონტეინერის შიგნით train_nn.R ნაგულისხმევი მნიშვნელობებით; თუ პირველი პოზიციური არგუმენტი არის "bash", მაშინ კონტეინერი დაიწყება ინტერაქტიულად ბრძანების ჭურვით. ყველა სხვა შემთხვევაში, პოზიციური არგუმენტების მნიშვნელობები იცვლება: CMD="Rscript /app/train_nn.R $@".

აღსანიშნავია, რომ დირექტორიები წყაროს მონაცემებით და მონაცემთა ბაზებით, ისევე როგორც გაწვრთნილი მოდელების შენახვის დირექტორია, დამონტაჟებულია კონტეინერში მასპინძელი სისტემიდან, რაც საშუალებას გაძლევთ მიიღოთ სკრიპტების შედეგები ზედმეტი მანიპულაციების გარეშე.

7. რამდენიმე GPU-ის გამოყენება Google Cloud-ზე

კონკურსის ერთ-ერთი მახასიათებელი იყო ძალიან ხმაურიანი მონაცემები (იხილეთ სათაურის სურათი, ნასესხები @Leigh.plt-დან ODS slack-დან). დიდი პარტიები გვეხმარება ამის წინააღმდეგ ბრძოლაში და კომპიუტერზე ექსპერიმენტების შემდეგ, 1 GPU-ით, გადავწყვიტეთ დაეუფლონ ტრენინგის მოდელებს რამდენიმე GPU-ზე ღრუბელში. გამოყენებული GoogleCloud (კარგი სახელმძღვანელო საფუძვლებისთვის) ხელმისაწვდომი კონფიგურაციების დიდი არჩევანის, გონივრული ფასების და $300 ბონუსის გამო. სიხარბის გამო შევუკვეთე 4xV100 ინსტანცია SSD-ით და ტონა ოპერატიული მეხსიერებით და ეს დიდი შეცდომა იყო. ასეთი მანქანა სწრაფად ჭამს ფულს; შეგიძლიათ ავარიული ექსპერიმენტების ჩატარება დადასტურებული მილსადენის გარეშე. საგანმანათლებლო მიზნებისთვის უმჯობესია K80 აიღოთ. მაგრამ დიდი რაოდენობით ოპერატიული მეხსიერება გამოგადგებათ - ღრუბლოვანი SSD-მ არ მოახდინა შთაბეჭდილება თავისი შესრულებით, ამიტომ მონაცემთა ბაზა გადაეცა dev/shm.

ყველაზე საინტერესოა კოდის ფრაგმენტი, რომელიც პასუხისმგებელია მრავალი GPU-ის გამოყენებაზე. პირველი, მოდელი იქმნება CPU-ზე კონტექსტური მენეჯერის გამოყენებით, ისევე როგორც პითონში:

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

შემდეგ დაუკომპლექტებელი (ეს მნიშვნელოვანია) მოდელი კოპირდება ხელმისაწვდომი GPU-ების მოცემულ რაოდენობაზე და მხოლოდ ამის შემდეგ ხდება მისი შედგენა:

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

ყველა ფენის გაყინვის კლასიკური ტექნიკა, გარდა უკანასკნელისა, ბოლო ფენის ვარჯიში, გაყინვა და მთელი მოდელის გადამზადება რამდენიმე GPU-სთვის, ვერ განხორციელდა.

ტრენინგის მონიტორინგი ხდებოდა გამოყენების გარეშე. ტენსორბორდი, შემოვიფარგლებით ჟურნალების ჩაწერით და მოდელების შენახვით ინფორმაციული სახელებით ყოველი ეპოქის შემდეგ:

გამოძახებები

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

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

8. დასკვნის ნაცვლად

მთელი რიგი პრობლემები, რომლებიც შეგვხვდა ჯერ კიდევ არ არის დაძლეული:

• в კერას არ არსებობს მზა ფუნქცია ოპტიმალური სწავლის სიჩქარის ავტომატურად მოსაძებნად (ანალოგური lr_finder ბიბლიოთეკაში სწრაფად.აი); გარკვეული ძალისხმევით, შესაძლებელია მესამე მხარის იმპლემენტაციების პორტირება R-ზე, მაგალითად, ეს;
• წინა პუნქტის შედეგად, რამდენიმე GPU-ს გამოყენებისას შეუძლებელი იყო ვარჯიშის სწორი სიჩქარის შერჩევა;
• არსებობს თანამედროვე ნერვული ქსელების არქიტექტურის ნაკლებობა, განსაკუთრებით იმიჯნეტზე წინასწარ მომზადებული;
• არავის ციკლის პოლიტიკა და სწავლის დისკრიმინაციული მაჩვენებლები (კოსინუსური ანილირება იყო ჩვენი მოთხოვნით განხორციელდა, მადლობა სკეიდანი).

რა სასარგებლო რამ ვისწავლეთ ამ კონკურსიდან:

• შედარებით დაბალი სიმძლავრის აპარატზე, შეგიძლიათ იმუშაოთ მონაცემთა ღირსეული (რამდენჯერ მეტი ოპერატიული მეხსიერებით) მოცულობით, ტკივილის გარეშე. პლასტიკური ჩანთა მონაცემები. მაგიდა ზოგავს მეხსიერებას ცხრილების ადგილზე მოდიფიცირების გამო, რაც თავიდან აიცილებს მათ კოპირებას და სწორად გამოყენებისას, მისი შესაძლებლობები თითქმის ყოველთვის აჩვენებს უმაღლეს სიჩქარეს სკრიპტირების ენებისთვის ჩვენთვის ცნობილ ყველა ხელსაწყოს შორის. მონაცემთა ბაზაში შენახვა საშუალებას გაძლევთ, ხშირ შემთხვევაში, საერთოდ არ იფიქროთ მთელი მონაცემთა RAM-ში შეკუმშვის აუცილებლობაზე.
• R-ში ნელი ფუნქციები შეიძლება შეიცვალოს სწრაფი ფუნქციებით C++-ში პაკეტის გამოყენებით Rcpp. თუ გამოყენების გარდა RcppThread ან Rcppპარალელური, ვიღებთ კროს პლატფორმის მრავალ ხრახნიან იმპლემენტაციას, ამიტომ არ არის საჭირო კოდის პარალელიზება R დონეზე.
• პაკეტი Rcpp შეიძლება გამოყენებულ იქნას C++-ის სერიოზული ცოდნის გარეშე, ასახულია საჭირო მინიმუმი აქ. სათაურის ფაილები მრავალი მაგარი C-ბიბლიოთეკისთვის, როგორიცაა xtensor ხელმისაწვდომია CRAN-ზე, ანუ იქმნება ინფრასტრუქტურა პროექტების განსახორციელებლად, რომლებიც აერთიანებს მზა მაღალი ხარისხის C++ კოდს R-ში. დამატებითი მოხერხებულობა არის სინტაქსის ხაზგასმა და სტატიკური C++ კოდის ანალიზატორი RStudio-ში.
• დოკოპტი საშუალებას გაძლევთ გაუშვათ დამოუკიდებელი სკრიპტები პარამეტრებით. ეს მოსახერხებელია დისტანციურ სერვერზე გამოსაყენებლად, მათ შორის. დოკერის ქვეშ. RStudio-ში არასასიამოვნოა მრავალსაათიანი ექსპერიმენტების ჩატარება ნერვული ქსელების ვარჯიშით და თავად სერვერზე IDE-ის დაყენება ყოველთვის არ არის გამართლებული.
• Docker უზრუნველყოფს კოდის პორტაბელურობას და შედეგების გამეორებას დეველოპერებს შორის OS-ის და ბიბლიოთეკების სხვადასხვა ვერსიით, ასევე სერვერებზე შესრულების მარტივობას. თქვენ შეგიძლიათ გაუშვათ მთელი სასწავლო მილსადენი მხოლოდ ერთი ბრძანებით.
• Google Cloud არის საბიუჯეტო გზა ძვირადღირებული აპარატურის ექსპერიმენტებისთვის, მაგრამ თქვენ უნდა აირჩიოთ კონფიგურაციები ფრთხილად.
• ინდივიდუალური კოდის ფრაგმენტების სიჩქარის გაზომვა ძალიან სასარგებლოა, განსაკუთრებით R და C++-ის კომბინირებისას და პაკეტთან ერთად. bench - ასევე ძალიან ადვილია.

საერთო ჯამში, ეს გამოცდილება ძალიან სასარგებლო იყო და ჩვენ ვაგრძელებთ მუშაობას წამოჭრილი ზოგიერთი საკითხის მოსაგვარებლად.

წყარო: www.habr.com