ਤਤਕਾਲ ਡਰਾਅ ਡੂਡਲ ਪਛਾਣ: R, C++ ਅਤੇ ਨਿਊਰਲ ਨੈੱਟਵਰਕਾਂ ਨਾਲ ਦੋਸਤੀ ਕਿਵੇਂ ਕਰੀਏ

ਹੇ ਹਬਰ!

ਪਿਛਲੀ ਗਿਰਾਵਟ ਵਿੱਚ, ਕਾਗਲ ਨੇ ਹੱਥਾਂ ਨਾਲ ਖਿੱਚੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਵਰਗੀਕ੍ਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਮੁਕਾਬਲੇ ਦੀ ਮੇਜ਼ਬਾਨੀ ਕੀਤੀ, ਤੇਜ਼ ਡਰਾਅ ਡੂਡਲ ਪਛਾਣ, ਜਿਸ ਵਿੱਚ, ਹੋਰਾਂ ਵਿੱਚ, ਆਰ-ਵਿਗਿਆਨੀਆਂ ਦੀ ਇੱਕ ਟੀਮ ਨੇ ਹਿੱਸਾ ਲਿਆ: ਆਰਟੇਮ ਕਲੇਵਤਸੋਵਾ, ਫਿਲਿਪਾ ਮੈਨੇਜਰ и ਆਂਦਰੇ ਓਗੁਰਤਸੋਵ. ਅਸੀਂ ਮੁਕਾਬਲੇ ਦਾ ਵਿਸਤਾਰ ਵਿੱਚ ਵਰਣਨ ਨਹੀਂ ਕਰਾਂਗੇ; ਜੋ ਪਹਿਲਾਂ ਹੀ ਕੀਤਾ ਜਾ ਚੁੱਕਾ ਹੈ ਹਾਲੀਆ ਪ੍ਰਕਾਸ਼ਨ.

ਇਸ ਵਾਰ ਮੈਡਲ ਫਾਰਮਿੰਗ ਨਾਲ ਕੰਮ ਨਹੀਂ ਹੋਇਆ, ਪਰ ਬਹੁਤ ਸਾਰਾ ਕੀਮਤੀ ਤਜਰਬਾ ਹਾਸਲ ਹੋਇਆ, ਇਸ ਲਈ ਮੈਂ ਕਮਿਊਨਿਟੀ ਨੂੰ ਕਾਗਲੇ ਅਤੇ ਰੋਜ਼ਾਨਾ ਦੇ ਕੰਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰੀਆਂ ਦਿਲਚਸਪ ਅਤੇ ਉਪਯੋਗੀ ਚੀਜ਼ਾਂ ਬਾਰੇ ਦੱਸਣਾ ਚਾਹਾਂਗਾ। ਚਰਚਾ ਕੀਤੇ ਗਏ ਵਿਸ਼ਿਆਂ ਵਿੱਚੋਂ: ਬਿਨਾਂ ਮੁਸ਼ਕਲ ਜੀਵਨ ਓਪਨਸੀਵੀ, JSON ਪਾਰਸਿੰਗ (ਇਹ ਉਦਾਹਰਨਾਂ R ਵਿੱਚ ਸਕ੍ਰਿਪਟਾਂ ਜਾਂ ਪੈਕੇਜਾਂ ਵਿੱਚ C++ ਕੋਡ ਦੇ ਏਕੀਕਰਨ ਦੀ ਜਾਂਚ ਕਰਦੀਆਂ ਹਨ। ਆਰ.ਸੀ.ਪੀ.ਪੀ), ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਪੈਰਾਮੀਟਰਾਈਜ਼ੇਸ਼ਨ ਅਤੇ ਅੰਤਮ ਹੱਲ ਦਾ ਡੌਕਰਾਈਜ਼ੇਸ਼ਨ। ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਲਈ ਢੁਕਵੇਂ ਰੂਪ ਵਿੱਚ ਸੰਦੇਸ਼ ਦੇ ਸਾਰੇ ਕੋਡ ਵਿੱਚ ਉਪਲਬਧ ਹਨ ਰਿਪੋਜ਼ਟਰੀਆਂ.

ਸਮੱਗਰੀ:

1. CSV ਤੋਂ MonetDB ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਡਾਟਾ ਲੋਡ ਕਰੋ
2. ਬੈਚਾਂ ਦੀ ਤਿਆਰੀ
3. ਡਾਟਾਬੇਸ ਤੋਂ ਬੈਚਾਂ ਨੂੰ ਅਨਲੋਡ ਕਰਨ ਲਈ ਇਟਰੇਟਰ
4. ਇੱਕ ਮਾਡਲ ਆਰਕੀਟੈਕਚਰ ਦੀ ਚੋਣ
5. ਸਕ੍ਰਿਪਟ ਪੈਰਾਮੀਟਰਾਈਜ਼ੇਸ਼ਨ
6. ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਡੌਕਰਾਈਜ਼ੇਸ਼ਨ
7. ਗੂਗਲ ਕਲਾਉਡ 'ਤੇ ਕਈ GPUs ਦੀ ਵਰਤੋਂ ਕਰਨਾ
8. ਸੰਪੂਰਨ ਹੋਣ ਦੇ ਬਜਾਏ

1. CSV ਤੋਂ ਮੋਨੇਟਡੀਬੀ ਡੇਟਾਬੇਸ ਵਿੱਚ ਕੁਸ਼ਲਤਾ ਨਾਲ ਡਾਟਾ ਲੋਡ ਕਰੋ

ਇਸ ਮੁਕਾਬਲੇ ਦਾ ਡੇਟਾ ਤਿਆਰ-ਕੀਤੀ ਚਿੱਤਰਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਨਹੀਂ, ਸਗੋਂ 340 CSV ਫਾਈਲਾਂ (ਹਰੇਕ ਕਲਾਸ ਲਈ ਇੱਕ ਫਾਈਲ) ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤਾ ਗਿਆ ਹੈ ਜਿਸ ਵਿੱਚ ਪੁਆਇੰਟ ਕੋਆਰਡੀਨੇਟਸ ਵਾਲੇ JSON ਹਨ। ਇਹਨਾਂ ਬਿੰਦੂਆਂ ਨੂੰ ਲਾਈਨਾਂ ਨਾਲ ਜੋੜ ਕੇ, ਅਸੀਂ 256x256 ਪਿਕਸਲ ਮਾਪਣ ਵਾਲੀ ਇੱਕ ਅੰਤਮ ਚਿੱਤਰ ਪ੍ਰਾਪਤ ਕਰਦੇ ਹਾਂ। ਨਾਲ ਹੀ ਹਰੇਕ ਰਿਕਾਰਡ ਲਈ ਇੱਕ ਲੇਬਲ ਹੁੰਦਾ ਹੈ ਜੋ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ ਕਿ ਕੀ ਡੇਟਾਸੈਟ ਇਕੱਤਰ ਕੀਤੇ ਜਾਣ ਵੇਲੇ ਵਰਤੇ ਗਏ ਵਰਗੀਕਰਣ ਦੁਆਰਾ ਤਸਵੀਰ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਪਛਾਣਿਆ ਗਿਆ ਸੀ, ਤਸਵੀਰ ਦੇ ਲੇਖਕ ਦੇ ਨਿਵਾਸ ਦੇ ਦੇਸ਼ ਦਾ ਇੱਕ ਦੋ-ਅੱਖਰਾਂ ਦਾ ਕੋਡ, ਇੱਕ ਵਿਲੱਖਣ ਪਛਾਣਕਰਤਾ, ਇੱਕ ਟਾਈਮਸਟੈਂਪ। ਅਤੇ ਇੱਕ ਕਲਾਸ ਨਾਮ ਜੋ ਫਾਈਲ ਨਾਮ ਨਾਲ ਮੇਲ ਖਾਂਦਾ ਹੈ। ਆਰਕਾਈਵ ਵਿੱਚ ਮੂਲ ਡੇਟਾ ਦੇ ਇੱਕ ਸਰਲ ਰੂਪ ਵਿੱਚ ਵਜ਼ਨ 7.4 GB ਅਤੇ ਅਨਪੈਕ ਕਰਨ ਤੋਂ ਬਾਅਦ ਲਗਭਗ 20 GB ਹੁੰਦਾ ਹੈ, ਅਨਪੈਕ ਕਰਨ ਤੋਂ ਬਾਅਦ ਪੂਰਾ ਡੇਟਾ 240 GB ਤੱਕ ਲੈ ਜਾਂਦਾ ਹੈ। ਆਯੋਜਕਾਂ ਨੇ ਇਹ ਯਕੀਨੀ ਬਣਾਇਆ ਕਿ ਦੋਵੇਂ ਸੰਸਕਰਣ ਇੱਕੋ ਡਰਾਇੰਗ ਨੂੰ ਦੁਬਾਰਾ ਤਿਆਰ ਕਰਦੇ ਹਨ, ਭਾਵ ਪੂਰਾ ਸੰਸਕਰਣ ਬੇਲੋੜਾ ਸੀ। ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ, ਗ੍ਰਾਫਿਕ ਫਾਈਲਾਂ ਵਿੱਚ ਜਾਂ ਐਰੇ ਦੇ ਰੂਪ ਵਿੱਚ 50 ਮਿਲੀਅਨ ਚਿੱਤਰਾਂ ਨੂੰ ਸਟੋਰ ਕਰਨਾ ਤੁਰੰਤ ਗੈਰ-ਲਾਭਕਾਰੀ ਮੰਨਿਆ ਗਿਆ ਸੀ, ਅਤੇ ਅਸੀਂ ਆਰਕਾਈਵ ਤੋਂ ਸਾਰੀਆਂ CSV ਫਾਈਲਾਂ ਨੂੰ ਮਿਲਾਉਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ train_simplified.zip ਹਰੇਕ ਬੈਚ ਲਈ "ਉੱਡਣ 'ਤੇ" ਲੋੜੀਂਦੇ ਆਕਾਰ ਦੀਆਂ ਤਸਵੀਰਾਂ ਦੀ ਅਗਲੀ ਪੀੜ੍ਹੀ ਦੇ ਨਾਲ ਡਾਟਾਬੇਸ ਵਿੱਚ।

ਇੱਕ ਚੰਗੀ ਤਰ੍ਹਾਂ ਸਾਬਤ ਪ੍ਰਣਾਲੀ ਨੂੰ DBMS ਵਜੋਂ ਚੁਣਿਆ ਗਿਆ ਸੀ ਮੋਨੇਟਡੀਬੀ, ਅਰਥਾਤ ਇੱਕ ਪੈਕੇਜ ਦੇ ਰੂਪ ਵਿੱਚ R ਲਈ ਇੱਕ ਲਾਗੂਕਰਨ MonetDBLite. ਪੈਕੇਜ ਵਿੱਚ ਡੇਟਾਬੇਸ ਸਰਵਰ ਦਾ ਇੱਕ ਏਮਬੈਡਡ ਸੰਸਕਰਣ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈ ਅਤੇ ਤੁਹਾਨੂੰ ਇੱਕ ਆਰ ਸੈਸ਼ਨ ਤੋਂ ਸਰਵਰ ਨੂੰ ਸਿੱਧਾ ਚੁੱਕਣ ਅਤੇ ਉੱਥੇ ਇਸਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇੱਕ ਡੇਟਾਬੇਸ ਬਣਾਉਣਾ ਅਤੇ ਇਸ ਨਾਲ ਜੁੜਨਾ ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ:

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 ਫਾਈਲਾਂ ਦੀ ਸਿੱਧੀ ਨਕਲ ਕਰਨਾ ਸੀ COPY OFFSET 2 INTO tablename FROM path USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORTਕਿੱਥੇ tablename - ਟੇਬਲ ਦਾ ਨਾਮ ਅਤੇ path - ਫਾਈਲ ਦਾ ਮਾਰਗ। ਆਰਕਾਈਵ ਦੇ ਨਾਲ ਕੰਮ ਕਰਦੇ ਸਮੇਂ, ਇਹ ਪਤਾ ਲਗਾਇਆ ਗਿਆ ਕਿ ਬਿਲਟ-ਇਨ ਲਾਗੂ ਕਰਨਾ unzip ਆਰ ਵਿੱਚ ਆਰਕਾਈਵ ਦੀਆਂ ਕਈ ਫਾਈਲਾਂ ਨਾਲ ਸਹੀ ਢੰਗ ਨਾਲ ਕੰਮ ਨਹੀਂ ਕਰਦਾ, ਇਸਲਈ ਅਸੀਂ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕੀਤੀ unzip (ਪੈਰਾਮੀਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ getOption("unzip")).

ਡਾਟਾਬੇਸ ਨੂੰ ਲਿਖਣ ਲਈ ਫੰਕਸ਼ਨ

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

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

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

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

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

  return(invisible(TRUE))
}

ਜੇਕਰ ਤੁਹਾਨੂੰ ਸਾਰਣੀ ਨੂੰ ਡੇਟਾਬੇਸ ਵਿੱਚ ਲਿਖਣ ਤੋਂ ਪਹਿਲਾਂ ਇਸਨੂੰ ਬਦਲਣ ਦੀ ਲੋੜ ਹੈ, ਤਾਂ ਇਹ ਆਰਗੂਮੈਂਟ ਵਿੱਚ ਪਾਸ ਕਰਨ ਲਈ ਕਾਫ਼ੀ ਹੈ preprocess ਫੰਕਸ਼ਨ ਜੋ ਡੇਟਾ ਨੂੰ ਬਦਲ ਦੇਵੇਗਾ।

ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਕ੍ਰਮਵਾਰ ਲੋਡ ਕਰਨ ਲਈ ਕੋਡ:

ਡਾਟਾਬੇਸ ਨੂੰ ਡਾਟਾ ਲਿਖਣਾ

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

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

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

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

ਵਰਤੀ ਗਈ ਡਰਾਈਵ ਦੀਆਂ ਗਤੀ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਆਧਾਰ 'ਤੇ ਡਾਟਾ ਲੋਡ ਕਰਨ ਦਾ ਸਮਾਂ ਵੱਖ-ਵੱਖ ਹੋ ਸਕਦਾ ਹੈ। ਸਾਡੇ ਕੇਸ ਵਿੱਚ, ਇੱਕ SSD ਦੇ ਅੰਦਰ ਜਾਂ ਇੱਕ ਫਲੈਸ਼ ਡਰਾਈਵ (ਸਰੋਤ ਫਾਈਲ) ਤੋਂ ਇੱਕ SSD (DB) ਵਿੱਚ ਪੜ੍ਹਨ ਅਤੇ ਲਿਖਣ ਵਿੱਚ 10 ਮਿੰਟ ਤੋਂ ਘੱਟ ਸਮਾਂ ਲੱਗਦਾ ਹੈ।

ਇੱਕ ਪੂਰਨ ਅੰਕ ਕਲਾਸ ਲੇਬਲ ਅਤੇ ਇੱਕ ਸੂਚਕਾਂਕ ਕਾਲਮ ਨਾਲ ਇੱਕ ਕਾਲਮ ਬਣਾਉਣ ਵਿੱਚ ਕੁਝ ਹੋਰ ਸਕਿੰਟ ਲੱਗਦੇ ਹਨORDERED INDEX) ਲਾਈਨ ਨੰਬਰਾਂ ਦੇ ਨਾਲ ਜਿਸ ਦੁਆਰਾ ਬੈਚ ਬਣਾਉਣ ਵੇਲੇ ਨਿਰੀਖਣਾਂ ਦਾ ਨਮੂਨਾ ਲਿਆ ਜਾਵੇਗਾ:

ਵਾਧੂ ਕਾਲਮ ਅਤੇ ਸੂਚਕਾਂਕ ਬਣਾਉਣਾ

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

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

ਫਲਾਈ 'ਤੇ ਇੱਕ ਬੈਚ ਬਣਾਉਣ ਦੀ ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਸਾਨੂੰ ਟੇਬਲ ਤੋਂ ਬੇਤਰਤੀਬ ਕਤਾਰਾਂ ਨੂੰ ਕੱਢਣ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਗਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਲੋੜ ਸੀ doodles. ਇਸਦੇ ਲਈ ਅਸੀਂ 3 ਟ੍ਰਿਕਸ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਉਸ ਕਿਸਮ ਦੀ ਅਯਾਮਤਾ ਨੂੰ ਘਟਾਉਣਾ ਸੀ ਜੋ ਨਿਰੀਖਣ ID ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ। ਮੂਲ ਡਾਟਾ ਸੈੱਟ ਵਿੱਚ, ID ਨੂੰ ਸਟੋਰ ਕਰਨ ਲਈ ਲੋੜੀਂਦੀ ਕਿਸਮ ਹੈ bigint, ਪਰ ਨਿਰੀਖਣਾਂ ਦੀ ਸੰਖਿਆ ਉਹਨਾਂ ਦੇ ਪਛਾਣਕਰਤਾਵਾਂ ਨੂੰ, ਆਰਡੀਨਲ ਨੰਬਰ ਦੇ ਬਰਾਬਰ, ਕਿਸਮ ਵਿੱਚ ਫਿੱਟ ਕਰਨਾ ਸੰਭਵ ਬਣਾਉਂਦੀ ਹੈ int. ਇਸ ਮਾਮਲੇ ਵਿੱਚ ਖੋਜ ਬਹੁਤ ਤੇਜ਼ ਹੈ. ਦੂਜੀ ਚਾਲ ਸੀ ਵਰਤਣੀ ORDERED INDEX - ਅਸੀਂ ਇਸ ਫੈਸਲੇ 'ਤੇ ਅਨੁਭਵੀ ਤੌਰ 'ਤੇ ਆਏ ਹਾਂ, ਸਾਰੀਆਂ ਉਪਲਬਧ ਚੀਜ਼ਾਂ ਵਿੱਚੋਂ ਲੰਘਣ ਤੋਂ ਬਾਅਦ ਚੋਣਾਂ. ਤੀਜਾ ਪੈਰਾਮੀਟਰਾਈਜ਼ਡ ਸਵਾਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਸੀ। ਵਿਧੀ ਦਾ ਸਾਰ ਇੱਕ ਵਾਰ ਕਮਾਂਡ ਨੂੰ ਚਲਾਉਣਾ ਹੈ PREPARE ਉਸੇ ਕਿਸਮ ਦੇ ਸਵਾਲਾਂ ਦਾ ਇੱਕ ਸਮੂਹ ਬਣਾਉਣ ਵੇਲੇ ਇੱਕ ਤਿਆਰ ਸਮੀਕਰਨ ਦੀ ਬਾਅਦ ਵਿੱਚ ਵਰਤੋਂ ਦੇ ਨਾਲ, ਪਰ ਅਸਲ ਵਿੱਚ ਇੱਕ ਸਧਾਰਨ ਦੀ ਤੁਲਨਾ ਵਿੱਚ ਇੱਕ ਫਾਇਦਾ ਹੈ SELECT ਅੰਕੜਾ ਗਲਤੀ ਦੀ ਸੀਮਾ ਦੇ ਅੰਦਰ ਨਿਕਲਿਆ।

ਡਾਟਾ ਅਪਲੋਡ ਕਰਨ ਦੀ ਪ੍ਰਕਿਰਿਆ 450 MB ਤੋਂ ਵੱਧ RAM ਦੀ ਖਪਤ ਨਹੀਂ ਕਰਦੀ ਹੈ। ਭਾਵ, ਵਰਣਿਤ ਪਹੁੰਚ ਤੁਹਾਨੂੰ ਲਗਭਗ ਕਿਸੇ ਵੀ ਬਜਟ ਹਾਰਡਵੇਅਰ 'ਤੇ ਦਸਾਂ ਗੀਗਾਬਾਈਟ ਵਜ਼ਨ ਵਾਲੇ ਡੇਟਾਸੈਟਾਂ ਨੂੰ ਮੂਵ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਜਿਸ ਵਿੱਚ ਕੁਝ ਸਿੰਗਲ-ਬੋਰਡ ਡਿਵਾਈਸਾਂ ਵੀ ਸ਼ਾਮਲ ਹਨ, ਜੋ ਕਿ ਬਹੁਤ ਵਧੀਆ ਹੈ।

ਜੋ ਕੁਝ ਬਚਿਆ ਹੈ ਉਹ ਹੈ (ਬੇਤਰਤੀਬ) ਡੇਟਾ ਨੂੰ ਮੁੜ ਪ੍ਰਾਪਤ ਕਰਨ ਦੀ ਗਤੀ ਨੂੰ ਮਾਪਣਾ ਅਤੇ ਵੱਖ-ਵੱਖ ਆਕਾਰਾਂ ਦੇ ਬੈਚਾਂ ਦਾ ਨਮੂਨਾ ਲੈਂਦੇ ਸਮੇਂ ਸਕੇਲਿੰਗ ਦਾ ਮੁਲਾਂਕਣ ਕਰਨਾ:

ਡਾਟਾਬੇਸ ਬੈਂਚਮਾਰਕ

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. ਨਤੀਜੇ ਵਾਲੀਆਂ ਤਸਵੀਰਾਂ ਨੂੰ ਟੈਂਸਰ ਵਿੱਚ ਬਦਲਣਾ।

ਪਾਈਥਨ ਕਰਨਲ ਵਿਚਕਾਰ ਮੁਕਾਬਲੇ ਦੇ ਹਿੱਸੇ ਵਜੋਂ, ਸਮੱਸਿਆ ਨੂੰ ਮੁੱਖ ਤੌਰ 'ਤੇ ਵਰਤ ਕੇ ਹੱਲ ਕੀਤਾ ਗਿਆ ਸੀ ਓਪਨਸੀਵੀ. R ਵਿੱਚ ਸਭ ਤੋਂ ਸਰਲ ਅਤੇ ਸਭ ਤੋਂ ਸਪੱਸ਼ਟ ਐਨਾਲਾਗਸ ਵਿੱਚੋਂ ਇੱਕ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦੇਵੇਗਾ:

R ਵਿੱਚ JSON ਤੋਂ ਟੈਂਸਰ ਪਰਿਵਰਤਨ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

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

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

ਡਰਾਇੰਗ ਸਟੈਂਡਰਡ R ਟੂਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ RAM ਵਿੱਚ ਸਟੋਰ ਕੀਤੀ ਇੱਕ ਅਸਥਾਈ PNG ਵਿੱਚ ਸੁਰੱਖਿਅਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ (ਲੀਨਕਸ ਉੱਤੇ, ਆਰਜ਼ੀ ਆਰ ਡਾਇਰੈਕਟਰੀਆਂ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸਥਿਤ ਹੁੰਦੀਆਂ ਹਨ। /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

ਇਹ ਲਾਗੂ ਕਰਨਾ ਸਾਡੇ ਲਈ ਸਭ ਤੋਂ ਅਨੁਕੂਲ ਜਾਪਦਾ ਹੈ, ਕਿਉਂਕਿ ਵੱਡੇ ਬੈਚਾਂ ਦੇ ਗਠਨ ਵਿੱਚ ਬਹੁਤ ਜ਼ਿਆਦਾ ਸਮਾਂ ਲੱਗਦਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਇੱਕ ਸ਼ਕਤੀਸ਼ਾਲੀ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਆਪਣੇ ਸਹਿਯੋਗੀਆਂ ਦੇ ਤਜ਼ਰਬੇ ਦਾ ਲਾਭ ਲੈਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਓਪਨਸੀਵੀ. ਉਸ ਸਮੇਂ R ਲਈ ਕੋਈ ਤਿਆਰ ਪੈਕੇਜ ਨਹੀਂ ਸੀ (ਹੁਣ ਕੋਈ ਨਹੀਂ ਹੈ), ਇਸਲਈ ਲੋੜੀਂਦੀ ਕਾਰਜਸ਼ੀਲਤਾ ਦਾ ਇੱਕ ਘੱਟੋ-ਘੱਟ ਲਾਗੂਕਰਨ C++ ਵਿੱਚ R ਕੋਡ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਏਕੀਕਰਣ ਦੇ ਨਾਲ ਲਿਖਿਆ ਗਿਆ ਸੀ। ਆਰ.ਸੀ.ਪੀ.ਪੀ.

ਸਮੱਸਿਆ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਪੈਕੇਜ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਸੀ:

1. ਓਪਨਸੀਵੀ ਚਿੱਤਰਾਂ ਅਤੇ ਡਰਾਇੰਗ ਲਾਈਨਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ। ਪੂਰਵ-ਸਥਾਪਤ ਸਿਸਟਮ ਲਾਇਬ੍ਰੇਰੀਆਂ ਅਤੇ ਸਿਰਲੇਖ ਫਾਈਲਾਂ, ਨਾਲ ਹੀ ਡਾਇਨਾਮਿਕ ਲਿੰਕਿੰਗ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ।

2. xtensor ਬਹੁ-ਆਯਾਮੀ ਐਰੇ ਅਤੇ ਟੈਂਸਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨ ਲਈ। ਅਸੀਂ ਉਸੇ ਨਾਮ ਦੇ R ਪੈਕੇਜ ਵਿੱਚ ਸ਼ਾਮਲ ਹੈਡਰ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ। ਲਾਇਬ੍ਰੇਰੀ ਤੁਹਾਨੂੰ ਬਹੁ-ਆਯਾਮੀ ਐਰੇ ਦੇ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀ ਹੈ, ਦੋਵੇਂ ਕਤਾਰ ਮੇਜਰ ਅਤੇ ਕਾਲਮ ਮੁੱਖ ਕ੍ਰਮ ਵਿੱਚ।

3. ndjson JSON ਨੂੰ ਪਾਰਸ ਕਰਨ ਲਈ। ਵਿੱਚ ਇਸ ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ xtensor ਆਟੋਮੈਟਿਕਲੀ ਜੇ ਇਹ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਮੌਜੂਦ ਹੈ।

4. RcppThread JSON ਤੋਂ ਵੈਕਟਰ ਦੀ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਸੰਗਠਿਤ ਕਰਨ ਲਈ। ਇਸ ਪੈਕੇਜ ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੀਤੀਆਂ ਸਿਰਲੇਖ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਗਈ ਹੈ। ਹੋਰ ਪ੍ਰਸਿੱਧ ਤੱਕ ਆਰਸੀਪੀਪੀਪੈਰਲਲ ਪੈਕੇਜ, ਹੋਰ ਚੀਜ਼ਾਂ ਦੇ ਨਾਲ, ਇੱਕ ਬਿਲਟ-ਇਨ ਲੂਪ ਇੰਟਰੱਪਟ ਵਿਧੀ ਹੈ।

ਇਹ ਇਸ ਵੱਲ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ xtensor ਇੱਕ ਦੇਵਤਾ ਸਾਬਤ ਹੋਇਆ: ਇਸ ਤੱਥ ਤੋਂ ਇਲਾਵਾ ਕਿ ਇਸਦੀ ਵਿਆਪਕ ਕਾਰਜਕੁਸ਼ਲਤਾ ਅਤੇ ਉੱਚ ਪ੍ਰਦਰਸ਼ਨ ਹੈ, ਇਸਦੇ ਡਿਵੈਲਪਰ ਕਾਫ਼ੀ ਜਵਾਬਦੇਹ ਸਾਬਤ ਹੋਏ ਅਤੇ ਪ੍ਰਸ਼ਨਾਂ ਦੇ ਤੁਰੰਤ ਅਤੇ ਵਿਸਥਾਰ ਵਿੱਚ ਜਵਾਬ ਦਿੱਤੇ। ਉਹਨਾਂ ਦੀ ਮਦਦ ਨਾਲ, ਓਪਨਸੀਵੀ ਮੈਟ੍ਰਿਕਸ ਦੇ ਐਕਸਟੈਂਸਰ ਟੈਂਸਰਾਂ ਵਿੱਚ ਪਰਿਵਰਤਨ ਨੂੰ ਲਾਗੂ ਕਰਨਾ ਸੰਭਵ ਸੀ, ਨਾਲ ਹੀ 3-ਅਯਾਮੀ ਚਿੱਤਰ ਟੈਂਸਰਾਂ ਨੂੰ ਸਹੀ ਮਾਪ ਦੇ 4-ਅਯਾਮੀ ਟੈਂਸਰ (ਬੈਚ ਖੁਦ) ਵਿੱਚ ਜੋੜਨ ਦਾ ਇੱਕ ਤਰੀਕਾ।

Rcpp, xtensor ਅਤੇ RcppThread ਸਿੱਖਣ ਲਈ ਸਮੱਗਰੀ

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

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

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

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

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

ਉਹਨਾਂ ਫਾਈਲਾਂ ਨੂੰ ਕੰਪਾਇਲ ਕਰਨ ਲਈ ਜੋ ਸਿਸਟਮ ਫਾਈਲਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਨ ਅਤੇ ਸਿਸਟਮ ਤੇ ਸਥਾਪਿਤ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਗਤੀਸ਼ੀਲ ਲਿੰਕਿੰਗ ਕਰਦੇ ਹਨ, ਅਸੀਂ ਪੈਕੇਜ ਵਿੱਚ ਲਾਗੂ ਪਲੱਗਇਨ ਵਿਧੀ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ ਆਰ.ਸੀ.ਪੀ.ਪੀ. ਆਪਣੇ ਆਪ ਮਾਰਗ ਅਤੇ ਫਲੈਗ ਲੱਭਣ ਲਈ, ਅਸੀਂ ਇੱਕ ਪ੍ਰਸਿੱਧ Linux ਉਪਯੋਗਤਾ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਹੈ pkg-config.

OpenCV ਲਾਇਬ੍ਰੇਰੀ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ Rcpp ਪਲੱਗਇਨ ਨੂੰ ਲਾਗੂ ਕਰਨਾ

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

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

ਪਲੱਗਇਨ ਦੀ ਕਾਰਵਾਈ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਸੰਕਲਨ ਪ੍ਰਕਿਰਿਆ ਦੇ ਦੌਰਾਨ ਹੇਠਾਂ ਦਿੱਤੇ ਮੁੱਲ ਬਦਲੇ ਜਾਣਗੇ:

Rcpp:::.plugins$opencv()$env

# $PKG_CXXFLAGS
# [1] "-I/usr/include/opencv"
#
# $PKG_LIBS
# [1] "-lopencv_shape -lopencv_stitching -lopencv_superres -lopencv_videostab -lopencv_aruco -lopencv_bgsegm -lopencv_bioinspired -lopencv_ccalib -lopencv_datasets -lopencv_dpm -lopencv_face -lopencv_freetype -lopencv_fuzzy -lopencv_hdf -lopencv_line_descriptor -lopencv_optflow -lopencv_video -lopencv_plot -lopencv_reg -lopencv_saliency -lopencv_stereo -lopencv_structured_light -lopencv_phase_unwrapping -lopencv_rgbd -lopencv_viz -lopencv_surface_matching -lopencv_text -lopencv_ximgproc -lopencv_calib3d -lopencv_features2d -lopencv_flann -lopencv_xobjdetect -lopencv_objdetect -lopencv_ml -lopencv_xphoto -lopencv_highgui -lopencv_videoio -lopencv_imgcodecs -lopencv_photo -lopencv_imgproc -lopencv_core"

JSON ਨੂੰ ਪਾਰਸ ਕਰਨ ਅਤੇ ਮਾਡਲ ਨੂੰ ਪ੍ਰਸਾਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਬੈਚ ਬਣਾਉਣ ਲਈ ਲਾਗੂਕਰਨ ਕੋਡ ਸਪੌਇਲਰ ਦੇ ਹੇਠਾਂ ਦਿੱਤਾ ਗਿਆ ਹੈ। ਪਹਿਲਾਂ, ਹੈਡਰ ਫਾਈਲਾਂ ਦੀ ਖੋਜ ਕਰਨ ਲਈ ਇੱਕ ਸਥਾਨਕ ਪ੍ਰੋਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਸ਼ਾਮਲ ਕਰੋ (ndjson ਲਈ ਲੋੜੀਂਦਾ):

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

C++ ਵਿੱਚ ਟੈਂਸਰ ਪਰਿਵਰਤਨ ਲਈ JSON ਨੂੰ ਲਾਗੂ ਕਰਨਾ

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

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

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

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

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

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

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

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

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

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

ਇਹ ਕੋਡ ਫਾਈਲ ਵਿੱਚ ਰੱਖਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ src/cv_xt.cpp ਅਤੇ ਕਮਾਂਡ ਨਾਲ ਕੰਪਾਇਲ ਕਰੋ Rcpp::sourceCpp(file = "src/cv_xt.cpp", env = .GlobalEnv); ਕੰਮ ਲਈ ਵੀ ਲੋੜੀਂਦਾ ਹੈ nlohmann/json.hpp ਤੱਕ REPOZITORIA. ਕੋਡ ਨੂੰ ਕਈ ਫੰਕਸ਼ਨਾਂ ਵਿੱਚ ਵੰਡਿਆ ਗਿਆ ਹੈ:

• 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 ਵਿੱਚ ਫਿੱਟ ਹੋਣ ਵਾਲੇ ਡੇਟਾ ਨੂੰ ਪ੍ਰੋਸੈਸ ਕਰਨ ਲਈ ਇੱਕ ਚੰਗੀ-ਲਾਇਕ ਪ੍ਰਤਿਸ਼ਠਾ ਹੈ, ਜਦੋਂ ਕਿ ਪਾਈਥਨ ਨੂੰ ਦੁਹਰਾਉਣ ਵਾਲੇ ਡੇਟਾ ਪ੍ਰੋਸੈਸਿੰਗ ਦੁਆਰਾ ਵਧੇਰੇ ਵਿਸ਼ੇਸ਼ਤਾ ਦਿੱਤੀ ਜਾਂਦੀ ਹੈ, ਜਿਸ ਨਾਲ ਤੁਸੀਂ ਆਸਾਨੀ ਨਾਲ ਅਤੇ ਕੁਦਰਤੀ ਤੌਰ 'ਤੇ ਆਊਟ-ਆਫ-ਕੋਰ ਗਣਨਾਵਾਂ (ਬਾਹਰੀ ਮੈਮੋਰੀ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਗਣਨਾ) ਨੂੰ ਲਾਗੂ ਕਰ ਸਕਦੇ ਹੋ। ਵਰਣਿਤ ਸਮੱਸਿਆ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਸਾਡੇ ਲਈ ਇੱਕ ਟਕਸਾਲੀ ਅਤੇ ਢੁਕਵੀਂ ਉਦਾਹਰਨ ਹੈ ਡੂੰਘੇ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਹਨ ਜੋ ਗਰੇਡੀਐਂਟ ਡਿਸੈਂਟ ਵਿਧੀ ਦੁਆਰਾ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਕੀਤੇ ਗਏ ਹਨ, ਜੋ ਕਿ ਨਿਰੀਖਣਾਂ ਦੇ ਇੱਕ ਛੋਟੇ ਜਿਹੇ ਹਿੱਸੇ, ਜਾਂ ਮਿੰਨੀ-ਬੈਚ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਹਰੇਕ ਪੜਾਅ 'ਤੇ ਗਰੇਡੀਐਂਟ ਦੇ ਅਨੁਮਾਨ ਦੇ ਨਾਲ ਹਨ।

ਪਾਈਥਨ ਵਿੱਚ ਲਿਖੇ ਡੂੰਘੇ ਸਿੱਖਣ ਦੇ ਫਰੇਮਵਰਕ ਵਿੱਚ ਵਿਸ਼ੇਸ਼ ਕਲਾਸਾਂ ਹੁੰਦੀਆਂ ਹਨ ਜੋ ਡੇਟਾ ਦੇ ਅਧਾਰ 'ਤੇ ਦੁਹਰਾਓ ਨੂੰ ਲਾਗੂ ਕਰਦੀਆਂ ਹਨ: ਟੇਬਲ, ਫੋਲਡਰਾਂ ਵਿੱਚ ਤਸਵੀਰਾਂ, ਬਾਈਨਰੀ ਫਾਰਮੈਟ, ਆਦਿ। ਤੁਸੀਂ ਤਿਆਰ ਵਿਕਲਪਾਂ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ ਜਾਂ ਖਾਸ ਕੰਮਾਂ ਲਈ ਆਪਣੇ ਖੁਦ ਦੇ ਲਿਖ ਸਕਦੇ ਹੋ। ਆਰ ਵਿੱਚ ਅਸੀਂ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀ ਦੀਆਂ ਸਾਰੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਾ ਲਾਭ ਲੈ ਸਕਦੇ ਹਾਂ ਕੇਰਸ ਇਸਦੇ ਵੱਖ-ਵੱਖ ਬੈਕਐਂਡਾਂ ਨਾਲ ਇੱਕੋ ਨਾਮ ਦੇ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ, ਜੋ ਬਦਲੇ ਵਿੱਚ ਪੈਕੇਜ ਦੇ ਸਿਖਰ 'ਤੇ ਕੰਮ ਕਰਦਾ ਹੈ ਜਾਲੀਦਾਰ. ਬਾਅਦ ਵਾਲਾ ਇੱਕ ਵੱਖਰੇ ਲੰਬੇ ਲੇਖ ਦਾ ਹੱਕਦਾਰ ਹੈ; ਇਹ ਤੁਹਾਨੂੰ ਨਾ ਸਿਰਫ਼ R ਤੋਂ Python ਕੋਡ ਚਲਾਉਣ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਸਗੋਂ ਤੁਹਾਨੂੰ R ਅਤੇ Python ਸੈਸ਼ਨਾਂ ਵਿਚਕਾਰ ਆਬਜੈਕਟ ਟ੍ਰਾਂਸਫਰ ਕਰਨ ਦੀ ਵੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ, ਆਟੋਮੈਟਿਕ ਹੀ ਸਾਰੇ ਲੋੜੀਂਦੇ ਪ੍ਰਕਾਰ ਦੇ ਪਰਿਵਰਤਨ ਕਰਦੇ ਹੋਏ।

ਅਸੀਂ MonetDBLite ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਾਰੇ ਡੇਟਾ ਨੂੰ RAM ਵਿੱਚ ਸਟੋਰ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਤੋਂ ਛੁਟਕਾਰਾ ਪਾ ਲਿਆ ਹੈ, ਸਾਰੇ "ਨਿਊਰਲ ਨੈਟਵਰਕ" ਕੰਮ ਪਾਈਥਨ ਵਿੱਚ ਅਸਲ ਕੋਡ ਦੁਆਰਾ ਕੀਤੇ ਜਾਣਗੇ, ਸਾਨੂੰ ਡੇਟਾ ਉੱਤੇ ਇੱਕ ਇਟਰੇਟਰ ਲਿਖਣਾ ਪਵੇਗਾ, ਕਿਉਂਕਿ ਇੱਥੇ ਕੁਝ ਵੀ ਤਿਆਰ ਨਹੀਂ ਹੈ। R ਜਾਂ Python ਵਿੱਚ ਅਜਿਹੀ ਸਥਿਤੀ ਲਈ। ਇਸਦੇ ਲਈ ਲਾਜ਼ਮੀ ਤੌਰ 'ਤੇ ਸਿਰਫ ਦੋ ਲੋੜਾਂ ਹਨ: ਇਸਨੂੰ ਇੱਕ ਬੇਅੰਤ ਲੂਪ ਵਿੱਚ ਬੈਚਾਂ ਨੂੰ ਵਾਪਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ ਅਤੇ ਇਸਦੀ ਸਥਿਤੀ ਨੂੰ ਦੁਹਰਾਓ ਦੇ ਵਿਚਕਾਰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ (ਆਰ ਵਿੱਚ ਬਾਅਦ ਵਾਲੇ ਨੂੰ ਬੰਦ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸਭ ਤੋਂ ਸਰਲ ਤਰੀਕੇ ਨਾਲ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ)। ਪਹਿਲਾਂ, ਇਸ ਨੂੰ ਸਪਸ਼ਟ ਤੌਰ 'ਤੇ ਆਰ ਐਰੇ ਨੂੰ ਇਟਰੇਟਰ ਦੇ ਅੰਦਰ ਨੰਪੀ ਐਰੇ ਵਿੱਚ ਬਦਲਣ ਦੀ ਲੋੜ ਸੀ, ਪਰ ਪੈਕੇਜ ਦਾ ਮੌਜੂਦਾ ਸੰਸਕਰਣ ਕੇਰਸ ਇਹ ਆਪਣੇ ਆਪ ਕਰਦਾ ਹੈ।

ਸਿਖਲਾਈ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਡੇਟਾ ਲਈ ਦੁਹਰਾਓ ਹੇਠ ਲਿਖੇ ਅਨੁਸਾਰ ਨਿਕਲਿਆ:

ਸਿਖਲਾਈ ਅਤੇ ਪ੍ਰਮਾਣਿਕਤਾ ਡੇਟਾ ਲਈ ਇਟਰੇਟਰ

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 ਹਰੇਕ ਸਟ੍ਰੋਕ ਨੂੰ ਇੱਕ ਨਵੇਂ ਰੰਗ ਵਿੱਚ ਖਿੱਚਿਆ ਗਿਆ ਹੈ) ਅਤੇ ਇਮੇਜਨੈੱਟ 'ਤੇ ਪਹਿਲਾਂ ਤੋਂ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਨੈਟਵਰਕਾਂ ਲਈ ਇੱਕ ਪ੍ਰੀ-ਪ੍ਰੋਸੈਸਿੰਗ ਸੂਚਕ। ਅੰਤਰਾਲ [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 ਅਤੇ ਲਿੰਕ ਦੁਆਰਾ ਸੋਧ - ਇਹਨਾਂ ਪੈਕੇਜ "ਚਿੱਪਾਂ" ਤੋਂ ਬਿਨਾਂ ਡੇਟਾ.ਟੈਬਲ R ਵਿੱਚ ਕਿਸੇ ਵੀ ਮਹੱਤਵਪੂਰਨ ਮਾਤਰਾ ਵਿੱਚ ਡੇਟਾ ਦੇ ਨਾਲ ਪ੍ਰਭਾਵਸ਼ਾਲੀ ਢੰਗ ਨਾਲ ਕੰਮ ਕਰਨ ਦੀ ਕਲਪਨਾ ਕਰਨਾ ਬਹੁਤ ਮੁਸ਼ਕਲ ਹੈ।

ਕੋਰ 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 GB ਕਾਫ਼ੀ ਹੈ)। ਲੀਨਕਸ ਵਿੱਚ, ਭਾਗ ਮੂਲ ਰੂਪ ਵਿੱਚ ਮਾਊਂਟ ਹੁੰਦਾ ਹੈ /dev/shm, ਅੱਧੀ RAM ਸਮਰੱਥਾ ਤੱਕ ਦਾ ਕਬਜ਼ਾ ਹੈ। ਤੁਸੀਂ ਸੰਪਾਦਨ ਕਰਕੇ ਹੋਰ ਉਜਾਗਰ ਕਰ ਸਕਦੇ ਹੋ /etc/fstabਵਰਗਾ ਰਿਕਾਰਡ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ tmpfs /dev/shm tmpfs defaults,size=25g 0 0. ਰੀਬੂਟ ਕਰਨਾ ਯਕੀਨੀ ਬਣਾਓ ਅਤੇ ਕਮਾਂਡ ਚਲਾ ਕੇ ਨਤੀਜਾ ਚੈੱਕ ਕਰੋ df -h.

ਟੈਸਟ ਡੇਟਾ ਲਈ ਇਟਰੇਟਰ ਬਹੁਤ ਸਰਲ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ, ਕਿਉਂਕਿ ਟੈਸਟ ਡੇਟਾਸੈਟ ਪੂਰੀ ਤਰ੍ਹਾਂ RAM ਵਿੱਚ ਫਿੱਟ ਹੁੰਦਾ ਹੈ:

ਟੈਸਟ ਡੇਟਾ ਲਈ ਇਟਰੇਟਰ

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

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

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

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

4. ਮਾਡਲ ਆਰਕੀਟੈਕਚਰ ਦੀ ਚੋਣ

ਸਭ ਤੋਂ ਪਹਿਲਾਂ ਵਰਤਿਆ ਗਿਆ ਆਰਕੀਟੈਕਚਰ ਸੀ ਮੋਬਾਈਲਨੈੱਟ v1, ਜਿਸ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਚਰਚਾ ਕੀਤੀ ਗਈ ਹੈ ਇਹ ਸੁਨੇਹਾ। ਇਹ ਮਿਆਰੀ ਦੇ ਤੌਰ 'ਤੇ ਸ਼ਾਮਿਲ ਕੀਤਾ ਗਿਆ ਹੈ ਕੇਰਸ ਅਤੇ, ਇਸਦੇ ਅਨੁਸਾਰ, R ਲਈ ਉਸੇ ਨਾਮ ਦੇ ਪੈਕੇਜ ਵਿੱਚ ਉਪਲਬਧ ਹੈ। ਪਰ ਜਦੋਂ ਇਸਨੂੰ ਸਿੰਗਲ-ਚੈਨਲ ਚਿੱਤਰਾਂ ਨਾਲ ਵਰਤਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕੀਤੀ ਗਈ, ਤਾਂ ਇੱਕ ਅਜੀਬ ਗੱਲ ਸਾਹਮਣੇ ਆਈ: ਇਨਪੁਟ ਟੈਂਸਰ ਵਿੱਚ ਹਮੇਸ਼ਾਂ ਮਾਪ ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ (batch, height, width, 3), ਭਾਵ, ਚੈਨਲਾਂ ਦੀ ਗਿਣਤੀ ਨੂੰ ਬਦਲਿਆ ਨਹੀਂ ਜਾ ਸਕਦਾ ਹੈ। ਪਾਈਥਨ ਵਿੱਚ ਅਜਿਹੀ ਕੋਈ ਸੀਮਾ ਨਹੀਂ ਹੈ, ਇਸਲਈ ਅਸੀਂ ਕਾਹਲੀ ਕੀਤੀ ਅਤੇ ਇਸ ਆਰਕੀਟੈਕਚਰ ਦੇ ਆਪਣੇ ਖੁਦ ਦੇ ਲਾਗੂਕਰਨ ਨੂੰ ਮੂਲ ਲੇਖ (ਕੇਰਸ ਸੰਸਕਰਣ ਵਿੱਚ ਛੱਡਣ ਤੋਂ ਬਿਨਾਂ) ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋਏ ਲਿਖਿਆ:

ਮੋਬਾਈਲਨੈੱਟ 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)

ਹੁਣ ਸਪਲਾਈ ਕੀਤੇ ਕਿਸੇ ਵੀ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇੱਕ ਯੂਨੀਵਰਸਲ ਫੰਕਸ਼ਨ ਲਿਖਣਾ ਮੁਸ਼ਕਲ ਨਹੀਂ ਹੈ ਕੇਰਸ ਇਮੇਜਨੈੱਟ 'ਤੇ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਵਜ਼ਨ ਦੇ ਨਾਲ ਜਾਂ ਬਿਨਾਂ ਮਾਡਲ:

ਰੈਡੀਮੇਡ ਆਰਕੀਟੈਕਚਰ ਲੋਡ ਕਰਨ ਲਈ ਫੰਕਸ਼ਨ

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(). ਅਸੀਂ ਕਦੇ ਵੀ ਇਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ, ਕਿਉਂਕਿ ਇਸ ਪੜਾਅ 'ਤੇ ਇਹ ਪਹਿਲਾਂ ਹੀ ਸਪੱਸ਼ਟ ਸੀ ਕਿ ਰੰਗੀਨ ਤਸਵੀਰਾਂ ਨਾਲ ਕੰਮ ਕਰਨਾ ਵਧੇਰੇ ਲਾਭਕਾਰੀ ਸੀ.

ਅਸੀਂ ਮੋਬਾਈਲਨੈੱਟ ਸੰਸਕਰਣ 1 ਅਤੇ 2, ਅਤੇ ਨਾਲ ਹੀ resnet34 ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਜ਼ਿਆਦਾਤਰ ਪ੍ਰਯੋਗ ਕੀਤੇ। ਹੋਰ ਆਧੁਨਿਕ ਆਰਕੀਟੈਕਚਰ ਜਿਵੇਂ ਕਿ SE-ResNeXt ਨੇ ਇਸ ਮੁਕਾਬਲੇ ਵਿੱਚ ਵਧੀਆ ਪ੍ਰਦਰਸ਼ਨ ਕੀਤਾ। ਬਦਕਿਸਮਤੀ ਨਾਲ, ਸਾਡੇ ਕੋਲ ਸਾਡੇ ਨਿਪਟਾਰੇ 'ਤੇ ਤਿਆਰ-ਕੀਤੇ ਅਮਲ ਨਹੀਂ ਸਨ, ਅਤੇ ਅਸੀਂ ਆਪਣਾ ਨਹੀਂ ਲਿਖਿਆ (ਪਰ ਅਸੀਂ ਜ਼ਰੂਰ ਲਿਖਾਂਗੇ)।

5. ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਪੈਰਾਮੀਟਰਾਈਜ਼ੇਸ਼ਨ

ਸਹੂਲਤ ਲਈ, ਸਿਖਲਾਈ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਸਾਰੇ ਕੋਡ ਨੂੰ ਇੱਕ ਸਿੰਗਲ ਸਕ੍ਰਿਪਟ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਜ਼ਾਇਨ ਕੀਤਾ ਗਿਆ ਸੀ, ਜਿਸਦੀ ਵਰਤੋਂ ਕਰਕੇ ਪੈਰਾਮੀਟਰਾਈਜ਼ ਕੀਤਾ ਗਿਆ ਸੀ 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)

ਪੈਕੇਜ docopt ਲਾਗੂ ਕਰਨ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ http://docopt.org/ ਇਸਦੀ ਮਦਦ ਨਾਲ, ਸਕ੍ਰਿਪਟਾਂ ਨੂੰ ਸਧਾਰਨ ਕਮਾਂਡਾਂ ਨਾਲ ਲਾਂਚ ਕੀਤਾ ਜਾਂਦਾ ਹੈ 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 ਪੈਕੇਜ ਵਿੱਚ ਤਬਦੀਲੀਆਂ ਨੂੰ ਧਿਆਨ ਵਿੱਚ ਨਹੀਂ ਰੱਖਣ ਦੇ ਕਾਰਨ, ਅਸੀਂ ਉਹਨਾਂ ਨੂੰ ਠੀਕ ਕਰਨ ਦੀ ਉਡੀਕ ਕਰ ਰਹੇ ਹਾਂ।

ਇਸ ਪਹੁੰਚ ਨੇ RStudio ਵਿੱਚ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਵਧੇਰੇ ਰਵਾਇਤੀ ਲਾਂਚ ਦੇ ਮੁਕਾਬਲੇ ਵੱਖ-ਵੱਖ ਮਾਡਲਾਂ ਦੇ ਨਾਲ ਪ੍ਰਯੋਗਾਂ ਨੂੰ ਮਹੱਤਵਪੂਰਨ ਤੌਰ 'ਤੇ ਤੇਜ਼ ਕਰਨਾ ਸੰਭਵ ਬਣਾਇਆ (ਅਸੀਂ ਪੈਕੇਜ ਨੂੰ ਇੱਕ ਸੰਭਾਵੀ ਵਿਕਲਪ ਵਜੋਂ ਨੋਟ ਕਰਦੇ ਹਾਂ। tfruns). ਪਰ ਮੁੱਖ ਫਾਇਦਾ ਇਸ ਲਈ RStudio ਨੂੰ ਸਥਾਪਿਤ ਕੀਤੇ ਬਿਨਾਂ, ਡੌਕਰ ਵਿੱਚ ਜਾਂ ਸਿਰਫ਼ ਸਰਵਰ 'ਤੇ ਸਕ੍ਰਿਪਟਾਂ ਦੀ ਸ਼ੁਰੂਆਤ ਨੂੰ ਆਸਾਨੀ ਨਾਲ ਪ੍ਰਬੰਧਿਤ ਕਰਨ ਦੀ ਸਮਰੱਥਾ ਹੈ।

6. ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਡੌਕਰਾਈਜ਼ੇਸ਼ਨ

ਅਸੀਂ ਟੀਮ ਦੇ ਮੈਂਬਰਾਂ ਵਿਚਕਾਰ ਸਿਖਲਾਈ ਮਾਡਲਾਂ ਅਤੇ ਕਲਾਉਡ ਵਿੱਚ ਤੇਜ਼ੀ ਨਾਲ ਤਾਇਨਾਤੀ ਲਈ ਵਾਤਾਵਰਣ ਦੀ ਪੋਰਟੇਬਿਲਟੀ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਣ ਲਈ ਡੌਕਰ ਦੀ ਵਰਤੋਂ ਕੀਤੀ। ਤੁਸੀਂ ਇਸ ਟੂਲ ਨਾਲ ਜਾਣੂ ਹੋਣਾ ਸ਼ੁਰੂ ਕਰ ਸਕਦੇ ਹੋ, ਜੋ ਕਿ ਇੱਕ ਆਰ ਪ੍ਰੋਗਰਾਮਰ ਲਈ ਮੁਕਾਬਲਤਨ ਅਸਾਧਾਰਨ ਹੈ, ਨਾਲ ਇਹ ਪ੍ਰਕਾਸ਼ਨਾਂ ਦੀ ਲੜੀ ਜਾਂ ਵੀਡੀਓ ਕੋਰਸ.

ਡੌਕਰ ਤੁਹਾਨੂੰ ਸਕ੍ਰੈਚ ਤੋਂ ਆਪਣੀਆਂ ਖੁਦ ਦੀਆਂ ਤਸਵੀਰਾਂ ਬਣਾਉਣ ਅਤੇ ਤੁਹਾਡੀਆਂ ਖੁਦ ਦੀਆਂ ਤਸਵੀਰਾਂ ਬਣਾਉਣ ਦੇ ਅਧਾਰ ਵਜੋਂ ਹੋਰ ਚਿੱਤਰਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦਾ ਹੈ। ਉਪਲਬਧ ਵਿਕਲਪਾਂ ਦਾ ਵਿਸ਼ਲੇਸ਼ਣ ਕਰਦੇ ਸਮੇਂ, ਅਸੀਂ ਇਸ ਸਿੱਟੇ 'ਤੇ ਪਹੁੰਚੇ ਕਿ NVIDIA, CUDA + cuDNN ਡਰਾਈਵਰਾਂ ਅਤੇ ਪਾਈਥਨ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਚਿੱਤਰ ਦਾ ਕਾਫ਼ੀ ਵੱਡਾ ਹਿੱਸਾ ਹੈ, ਅਤੇ ਅਸੀਂ ਅਧਿਕਾਰਤ ਚਿੱਤਰ ਨੂੰ ਅਧਾਰ ਵਜੋਂ ਲੈਣ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। tensorflow/tensorflow:1.12.0-gpu, ਉੱਥੇ ਲੋੜੀਂਦੇ R ਪੈਕੇਜ ਸ਼ਾਮਲ ਕਰਨਾ।

ਫਾਈਨਲ ਡੌਕਰ ਫਾਈਲ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦੀ ਸੀ:

ਡੌਕਰਫਾਈਲ

FROM tensorflow/tensorflow:1.12.0-gpu

MAINTAINER Artem Klevtsov <[email protected]>

SHELL ["/bin/bash", "-c"]

ARG LOCALE="en_US.UTF-8"
ARG APT_PKG="libopencv-dev r-base r-base-dev littler"
ARG R_BIN_PKG="futile.logger checkmate data.table rcpp rapidjsonr dbi keras jsonlite curl digest remotes"
ARG R_SRC_PKG="xtensor RcppThread docopt MonetDBLite"
ARG PY_PIP_PKG="keras"
ARG DIRS="/db /app /app/data /app/models /app/logs"

RUN source /etc/os-release && 
    echo "deb https://cloud.r-project.org/bin/linux/ubuntu ${UBUNTU_CODENAME}-cran35/" > /etc/apt/sources.list.d/cran35.list && 
    apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9 && 
    add-apt-repository -y ppa:marutter/c2d4u3.5 && 
    add-apt-repository -y ppa:timsc/opencv-3.4 && 
    apt-get update && 
    apt-get install -y locales && 
    locale-gen ${LOCALE} && 
    apt-get install -y --no-install-recommends ${APT_PKG} && 
    ln -s /usr/lib/R/site-library/littler/examples/install.r /usr/local/bin/install.r && 
    ln -s /usr/lib/R/site-library/littler/examples/install2.r /usr/local/bin/install2.r && 
    ln -s /usr/lib/R/site-library/littler/examples/installGithub.r /usr/local/bin/installGithub.r && 
    echo 'options(Ncpus = parallel::detectCores())' >> /etc/R/Rprofile.site && 
    echo 'options(repos = c(CRAN = "https://cloud.r-project.org"))' >> /etc/R/Rprofile.site && 
    apt-get install -y $(printf "r-cran-%s " ${R_BIN_PKG}) && 
    install.r ${R_SRC_PKG} && 
    pip install ${PY_PIP_PKG} && 
    mkdir -p ${DIRS} && 
    chmod 777 ${DIRS} && 
    rm -rf /tmp/downloaded_packages/ /tmp/*.rds && 
    rm -rf /var/lib/apt/lists/*

COPY utils /app/utils
COPY src /app/src
COPY tests /app/tests
COPY bin/*.R /app/

ENV DBDIR="/db"
ENV CUDA_HOME="/usr/local/cuda"
ENV PATH="/app:${PATH}"

WORKDIR /app

VOLUME /db
VOLUME /app

CMD bash

ਸਹੂਲਤ ਲਈ, ਵਰਤੇ ਗਏ ਪੈਕੇਜ ਵੇਰੀਏਬਲ ਵਿੱਚ ਰੱਖੇ ਗਏ ਸਨ; ਲਿਖਤੀ ਸਕ੍ਰਿਪਟਾਂ ਦਾ ਵੱਡਾ ਹਿੱਸਾ ਅਸੈਂਬਲੀ ਦੌਰਾਨ ਡੱਬਿਆਂ ਦੇ ਅੰਦਰ ਨਕਲ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਅਸੀਂ ਕਮਾਂਡ ਸ਼ੈੱਲ ਨੂੰ ਵੀ ਬਦਲਿਆ ਹੈ /bin/bash ਸਮੱਗਰੀ ਦੀ ਵਰਤੋਂ ਵਿੱਚ ਆਸਾਨੀ ਲਈ /etc/os-release. ਇਹ ਕੋਡ ਵਿੱਚ OS ਸੰਸਕਰਣ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੀ ਜ਼ਰੂਰਤ ਤੋਂ ਬਚਿਆ ਹੈ।

ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਛੋਟੀ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਲਿਖੀ ਗਈ ਸੀ ਜੋ ਤੁਹਾਨੂੰ ਕਈ ਕਮਾਂਡਾਂ ਦੇ ਨਾਲ ਇੱਕ ਕੰਟੇਨਰ ਲਾਂਚ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਇਹ ਤੰਤੂ ਨੈੱਟਵਰਕਾਂ ਦੀ ਸਿਖਲਾਈ ਲਈ ਸਕ੍ਰਿਪਟਾਂ ਹੋ ਸਕਦੀਆਂ ਹਨ ਜੋ ਪਹਿਲਾਂ ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਰੱਖੇ ਗਏ ਸਨ, ਜਾਂ ਕੰਟੇਨਰ ਦੇ ਸੰਚਾਲਨ ਨੂੰ ਡੀਬੱਗ ਕਰਨ ਅਤੇ ਨਿਗਰਾਨੀ ਕਰਨ ਲਈ ਇੱਕ ਕਮਾਂਡ ਸ਼ੈੱਲ:

ਕੰਟੇਨਰ ਨੂੰ ਲਾਂਚ ਕਰਨ ਲਈ ਸਕ੍ਰਿਪਟ

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

ਜੇਕਰ ਇਹ ਬੈਸ਼ ਸਕ੍ਰਿਪਟ ਪੈਰਾਮੀਟਰਾਂ ਤੋਂ ਬਿਨਾਂ ਚਲਾਈ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਸਕ੍ਰਿਪਟ ਨੂੰ ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਬੁਲਾਇਆ ਜਾਵੇਗਾ train_nn.R ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਦੇ ਨਾਲ; ਜੇਕਰ ਪਹਿਲੀ ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟ "bash" ਹੈ, ਤਾਂ ਕੰਟੇਨਰ ਕਮਾਂਡ ਸ਼ੈੱਲ ਨਾਲ ਇੰਟਰਐਕਟਿਵ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂ ਹੋਵੇਗਾ। ਹੋਰ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਸਥਿਤੀ ਸੰਬੰਧੀ ਆਰਗੂਮੈਂਟਾਂ ਦੇ ਮੁੱਲ ਬਦਲੇ ਜਾਂਦੇ ਹਨ: CMD="Rscript /app/train_nn.R $@".

ਇਹ ਧਿਆਨ ਦੇਣ ਯੋਗ ਹੈ ਕਿ ਸਰੋਤ ਡੇਟਾ ਅਤੇ ਡੇਟਾਬੇਸ ਵਾਲੀਆਂ ਡਾਇਰੈਕਟਰੀਆਂ, ਅਤੇ ਨਾਲ ਹੀ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਮਾਡਲਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਲਈ ਡਾਇਰੈਕਟਰੀ, ਹੋਸਟ ਸਿਸਟਮ ਤੋਂ ਕੰਟੇਨਰ ਦੇ ਅੰਦਰ ਮਾਊਂਟ ਕੀਤੀਆਂ ਗਈਆਂ ਹਨ, ਜੋ ਤੁਹਾਨੂੰ ਸਕ੍ਰਿਪਟਾਂ ਦੇ ਨਤੀਜਿਆਂ ਨੂੰ ਬੇਲੋੜੀ ਹੇਰਾਫੇਰੀ ਤੋਂ ਬਿਨਾਂ ਐਕਸੈਸ ਕਰਨ ਦੀ ਆਗਿਆ ਦਿੰਦੀਆਂ ਹਨ.

7. ਗੂਗਲ ਕਲਾਉਡ 'ਤੇ ਕਈ GPUs ਦੀ ਵਰਤੋਂ ਕਰਨਾ

ਮੁਕਾਬਲੇ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚੋਂ ਇੱਕ ਬਹੁਤ ਰੌਲਾ-ਰੱਪਾ ਵਾਲਾ ਡੇਟਾ ਸੀ (ਸਿਰਲੇਖ ਤਸਵੀਰ ਦੇਖੋ, ODS ਸਲੈਕ ਤੋਂ @Leigh.plt ਤੋਂ ਉਧਾਰ ਲਿਆ ਗਿਆ)। ਵੱਡੇ ਬੈਚ ਇਸ ਨਾਲ ਲੜਨ ਵਿੱਚ ਮਦਦ ਕਰਦੇ ਹਨ, ਅਤੇ 1 GPU ਵਾਲੇ ਇੱਕ PC 'ਤੇ ਪ੍ਰਯੋਗਾਂ ਤੋਂ ਬਾਅਦ, ਅਸੀਂ ਕਲਾਉਡ ਵਿੱਚ ਕਈ GPUs 'ਤੇ ਸਿਖਲਾਈ ਮਾਡਲਾਂ ਵਿੱਚ ਮੁਹਾਰਤ ਹਾਸਲ ਕਰਨ ਦਾ ਫੈਸਲਾ ਕੀਤਾ ਹੈ। ਵਰਤਿਆ GoogleCloud (ਬੁਨਿਆਦੀ ਲਈ ਚੰਗੀ ਗਾਈਡ) ਉਪਲਬਧ ਸੰਰਚਨਾਵਾਂ, ਵਾਜਬ ਕੀਮਤਾਂ ਅਤੇ $300 ਬੋਨਸ ਦੀ ਵੱਡੀ ਚੋਣ ਦੇ ਕਾਰਨ। ਲਾਲਚ ਦੇ ਕਾਰਨ, ਮੈਂ ਇੱਕ SSD ਅਤੇ ਇੱਕ ਟਨ RAM ਦੇ ਨਾਲ ਇੱਕ 4xV100 ਉਦਾਹਰਣ ਦਾ ਆਰਡਰ ਕੀਤਾ, ਅਤੇ ਇਹ ਇੱਕ ਵੱਡੀ ਗਲਤੀ ਸੀ। ਅਜਿਹੀ ਮਸ਼ੀਨ ਤੇਜ਼ੀ ਨਾਲ ਪੈਸਾ ਖਾ ਜਾਂਦੀ ਹੈ; ਤੁਸੀਂ ਬਿਨਾਂ ਸਾਬਤ ਪਾਈਪਲਾਈਨ ਦੇ ਟੁੱਟੇ ਪ੍ਰਯੋਗ ਕਰ ਸਕਦੇ ਹੋ। ਵਿਦਿਅਕ ਉਦੇਸ਼ਾਂ ਲਈ, K80 ਲੈਣਾ ਬਿਹਤਰ ਹੈ. ਪਰ ਰੈਮ ਦੀ ਵੱਡੀ ਮਾਤਰਾ ਕੰਮ ਵਿੱਚ ਆਈ - ਕਲਾਉਡ SSD ਨੇ ਇਸਦੇ ਪ੍ਰਦਰਸ਼ਨ ਨਾਲ ਪ੍ਰਭਾਵਤ ਨਹੀਂ ਕੀਤਾ, ਇਸਲਈ ਡੇਟਾਬੇਸ ਨੂੰ ਟ੍ਰਾਂਸਫਰ ਕੀਤਾ ਗਿਆ ਸੀ dev/shm.

ਸਭ ਤੋਂ ਵੱਧ ਦਿਲਚਸਪੀ ਦਾ ਕੋਡ ਫਰੈਗਮੈਂਟ ਹੈ ਜੋ ਮਲਟੀਪਲ GPUs ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ। ਪਹਿਲਾਂ, ਮਾਡਲ ਨੂੰ 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
  )
})

ਫਿਰ ਅਣਕੰਪਾਈਲਡ (ਇਹ ਮਹੱਤਵਪੂਰਨ ਹੈ) ਮਾਡਲ ਨੂੰ ਉਪਲਬਧ 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)
)

ਆਖਰੀ ਨੂੰ ਛੱਡ ਕੇ ਸਾਰੀਆਂ ਲੇਅਰਾਂ ਨੂੰ ਫ੍ਰੀਜ਼ ਕਰਨ, ਆਖਰੀ ਲੇਅਰ ਨੂੰ ਟਰੇਨਿੰਗ ਦੇਣ, ਕਈ GPUs ਲਈ ਪੂਰੇ ਮਾਡਲ ਨੂੰ ਅਨਫ੍ਰੀਜ਼ ਕਰਨ ਅਤੇ ਦੁਬਾਰਾ ਸਿਖਲਾਈ ਦੇਣ ਦੀ ਕਲਾਸਿਕ ਤਕਨੀਕ ਲਾਗੂ ਨਹੀਂ ਕੀਤੀ ਜਾ ਸਕੀ।

ਸਿਖਲਾਈ ਦੀ ਵਰਤੋਂ ਤੋਂ ਬਿਨਾਂ ਨਿਗਰਾਨੀ ਕੀਤੀ ਗਈ ਸੀ. ਟੈਂਸਰਬੋਰਡ, ਆਪਣੇ ਆਪ ਨੂੰ ਲੌਗ ਰਿਕਾਰਡ ਕਰਨ ਅਤੇ ਹਰੇਕ ਯੁੱਗ ਤੋਂ ਬਾਅਦ ਜਾਣਕਾਰੀ ਵਾਲੇ ਨਾਵਾਂ ਦੇ ਨਾਲ ਮਾਡਲਾਂ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨ ਤੱਕ ਸੀਮਤ ਕਰਨਾ:

ਕਾਲਬੈਕਸ

# Шаблон имени файла лога
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 ਨੂੰ ਪੋਰਟ ਕਰਨਾ ਸੰਭਵ ਹੈ, ਉਦਾਹਰਨ ਲਈ, ਇਹ;
• ਪਿਛਲੇ ਬਿੰਦੂ ਦੇ ਨਤੀਜੇ ਵਜੋਂ, ਕਈ GPUs ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਸਹੀ ਸਿਖਲਾਈ ਦੀ ਗਤੀ ਦੀ ਚੋਣ ਕਰਨਾ ਸੰਭਵ ਨਹੀਂ ਸੀ;
• ਆਧੁਨਿਕ ਨਿਊਰਲ ਨੈੱਟਵਰਕ ਆਰਕੀਟੈਕਚਰ ਦੀ ਘਾਟ ਹੈ, ਖਾਸ ਤੌਰ 'ਤੇ ਉਹ ਜੋ ਇਮੇਜਨੈੱਟ 'ਤੇ ਪਹਿਲਾਂ ਤੋਂ ਸਿਖਲਾਈ ਪ੍ਰਾਪਤ ਹਨ;
• ਕੋਈ ਇੱਕ ਚੱਕਰ ਨੀਤੀ ਅਤੇ ਪੱਖਪਾਤੀ ਸਿੱਖਣ ਦੀਆਂ ਦਰਾਂ ਨਹੀਂ (ਕੋਸਾਈਨ ਐਨੀਲਿੰਗ ਸਾਡੀ ਬੇਨਤੀ 'ਤੇ ਸੀ ਲਾਗੂ ਕੀਤਾ, ਤੁਹਾਡਾ ਧੰਨਵਾਦ ਸਕਾਈਡਨ).

ਇਸ ਮੁਕਾਬਲੇ ਤੋਂ ਕਿਹੜੀਆਂ ਲਾਭਦਾਇਕ ਗੱਲਾਂ ਸਿੱਖੀਆਂ ਗਈਆਂ:

• ਮੁਕਾਬਲਤਨ ਘੱਟ-ਪਾਵਰ ਹਾਰਡਵੇਅਰ 'ਤੇ, ਤੁਸੀਂ ਬਿਨਾਂ ਦਰਦ ਦੇ ਡਾਟਾ ਦੇ ਵਿਨੀਤ (ਕਈ ਵਾਰ RAM ਦੇ ਆਕਾਰ) ਵਾਲੀਅਮ ਨਾਲ ਕੰਮ ਕਰ ਸਕਦੇ ਹੋ। ਪਲਾਸਟਿਕ ਬੈਗ ਡੇਟਾ.ਟੈਬਲ ਟੇਬਲਾਂ ਦੀ ਥਾਂ-ਥਾਂ ਸੰਸ਼ੋਧਨ ਕਰਕੇ ਮੈਮੋਰੀ ਨੂੰ ਬਚਾਉਂਦਾ ਹੈ, ਜੋ ਉਹਨਾਂ ਦੀ ਨਕਲ ਕਰਨ ਤੋਂ ਬਚਦਾ ਹੈ, ਅਤੇ ਜਦੋਂ ਸਹੀ ਢੰਗ ਨਾਲ ਵਰਤਿਆ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਇਸਦੀਆਂ ਸਮਰੱਥਾਵਾਂ ਲਗਭਗ ਹਮੇਸ਼ਾਂ ਸਭ ਤੋਂ ਉੱਚੀ ਗਤੀ ਦਰਸਾਉਂਦੀਆਂ ਹਨ ਜੋ ਸਾਨੂੰ ਸਕ੍ਰਿਪਟਿੰਗ ਭਾਸ਼ਾਵਾਂ ਲਈ ਜਾਣੀਆਂ ਜਾਂਦੀਆਂ ਹਨ। ਡੇਟਾਬੇਸ ਵਿੱਚ ਡੇਟਾ ਨੂੰ ਸੁਰੱਖਿਅਤ ਕਰਨਾ ਤੁਹਾਨੂੰ, ਬਹੁਤ ਸਾਰੇ ਮਾਮਲਿਆਂ ਵਿੱਚ, ਪੂਰੇ ਡੇਟਾਸੈਟ ਨੂੰ RAM ਵਿੱਚ ਨਿਚੋੜਨ ਦੀ ਜ਼ਰੂਰਤ ਬਾਰੇ ਬਿਲਕੁਲ ਵੀ ਨਹੀਂ ਸੋਚਣ ਦਿੰਦਾ ਹੈ।
• R ਵਿੱਚ ਹੌਲੀ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪੈਕੇਜ ਦੀ ਵਰਤੋਂ ਕਰਕੇ C++ ਵਿੱਚ ਤੇਜ਼ ਫੰਕਸ਼ਨਾਂ ਨਾਲ ਬਦਲਿਆ ਜਾ ਸਕਦਾ ਹੈ ਆਰ.ਸੀ.ਪੀ.ਪੀ. ਜੇਕਰ ਇਸ ਤੋਂ ਇਲਾਵਾ ਵਰਤੋਂ ਕੀਤੀ ਜਾਵੇ RcppThread ਜ ਆਰਸੀਪੀਪੀਪੈਰਲਲ, ਸਾਨੂੰ ਕ੍ਰਾਸ-ਪਲੇਟਫਾਰਮ ਮਲਟੀ-ਥ੍ਰੈਡਡ ਲਾਗੂਕਰਨ ਮਿਲਦਾ ਹੈ, ਇਸਲਈ R ਪੱਧਰ 'ਤੇ ਕੋਡ ਨੂੰ ਸਮਾਨਾਂਤਰ ਬਣਾਉਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ।
• ਪੈਕੇਜ ਆਰ.ਸੀ.ਪੀ.ਪੀ C++ ਦੇ ਗੰਭੀਰ ਗਿਆਨ ਤੋਂ ਬਿਨਾਂ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ, ਲੋੜੀਂਦੀ ਘੱਟੋ-ਘੱਟ ਰੂਪਰੇਖਾ ਦਿੱਤੀ ਗਈ ਹੈ ਇੱਥੇ. ਜਿਵੇਂ ਕਿ ਬਹੁਤ ਸਾਰੀਆਂ ਠੰਡੀਆਂ ਸੀ-ਲਾਇਬ੍ਰੇਰੀਆਂ ਲਈ ਹੈਡਰ ਫਾਈਲਾਂ xtensor CRAN 'ਤੇ ਉਪਲਬਧ ਹੈ, ਯਾਨੀ ਕਿ, ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਇੱਕ ਬੁਨਿਆਦੀ ਢਾਂਚਾ ਬਣਾਇਆ ਜਾ ਰਿਹਾ ਹੈ ਜੋ ਤਿਆਰ ਕੀਤੇ ਉੱਚ-ਪ੍ਰਦਰਸ਼ਨ ਵਾਲੇ C++ ਕੋਡ ਨੂੰ R ਵਿੱਚ ਜੋੜਦੇ ਹਨ। ਵਾਧੂ ਸਹੂਲਤ RStudio ਵਿੱਚ ਸਿੰਟੈਕਸ ਹਾਈਲਾਈਟਿੰਗ ਅਤੇ ਇੱਕ ਸਥਿਰ C++ ਕੋਡ ਐਨਾਲਾਈਜ਼ਰ ਹੈ।
• docopt ਤੁਹਾਨੂੰ ਪੈਰਾਮੀਟਰਾਂ ਨਾਲ ਸਵੈ-ਨਿਰਭਰ ਸਕ੍ਰਿਪਟਾਂ ਚਲਾਉਣ ਦੀ ਆਗਿਆ ਦਿੰਦਾ ਹੈ। ਇਹ ਰਿਮੋਟ ਸਰਵਰ 'ਤੇ ਵਰਤਣ ਲਈ ਸੁਵਿਧਾਜਨਕ ਹੈ, ਸਮੇਤ। ਡੌਕਰ ਦੇ ਅਧੀਨ. RStudio ਵਿੱਚ, ਸਿਖਲਾਈ ਨਿਊਰਲ ਨੈੱਟਵਰਕਾਂ ਦੇ ਨਾਲ ਕਈ ਘੰਟੇ ਪ੍ਰਯੋਗ ਕਰਨਾ ਅਸੁਵਿਧਾਜਨਕ ਹੈ, ਅਤੇ ਸਰਵਰ 'ਤੇ IDE ਨੂੰ ਸਥਾਪਿਤ ਕਰਨਾ ਹਮੇਸ਼ਾ ਜਾਇਜ਼ ਨਹੀਂ ਹੁੰਦਾ ਹੈ।
• ਡੌਕਰ ਕੋਡ ਪੋਰਟੇਬਿਲਟੀ ਅਤੇ OS ਅਤੇ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੇ ਵੱਖ-ਵੱਖ ਸੰਸਕਰਣਾਂ ਵਾਲੇ ਡਿਵੈਲਪਰਾਂ ਵਿਚਕਾਰ ਨਤੀਜਿਆਂ ਦੀ ਪੁਨਰ-ਉਤਪਾਦਨਯੋਗਤਾ ਦੇ ਨਾਲ ਨਾਲ ਸਰਵਰਾਂ 'ਤੇ ਐਗਜ਼ੀਕਿਊਸ਼ਨ ਦੀ ਸੌਖ ਨੂੰ ਯਕੀਨੀ ਬਣਾਉਂਦਾ ਹੈ। ਤੁਸੀਂ ਸਿਰਫ਼ ਇੱਕ ਕਮਾਂਡ ਨਾਲ ਪੂਰੀ ਸਿਖਲਾਈ ਪਾਈਪਲਾਈਨ ਲਾਂਚ ਕਰ ਸਕਦੇ ਹੋ।
• ਗੂਗਲ ਕਲਾਉਡ ਮਹਿੰਗੇ ਹਾਰਡਵੇਅਰ 'ਤੇ ਪ੍ਰਯੋਗ ਕਰਨ ਦਾ ਇੱਕ ਬਜਟ-ਅਨੁਕੂਲ ਤਰੀਕਾ ਹੈ, ਪਰ ਤੁਹਾਨੂੰ ਸੰਰਚਨਾਵਾਂ ਨੂੰ ਧਿਆਨ ਨਾਲ ਚੁਣਨ ਦੀ ਲੋੜ ਹੈ।
• ਵਿਅਕਤੀਗਤ ਕੋਡ ਦੇ ਟੁਕੜਿਆਂ ਦੀ ਗਤੀ ਨੂੰ ਮਾਪਣਾ ਬਹੁਤ ਲਾਭਦਾਇਕ ਹੈ, ਖਾਸ ਕਰਕੇ ਜਦੋਂ R ਅਤੇ C++ ਨੂੰ ਜੋੜਦੇ ਹੋਏ, ਅਤੇ ਪੈਕੇਜ ਦੇ ਨਾਲ ਬੈਂਚ - ਇਹ ਵੀ ਬਹੁਤ ਆਸਾਨ.

ਕੁੱਲ ਮਿਲਾ ਕੇ ਇਹ ਤਜਰਬਾ ਬਹੁਤ ਲਾਭਦਾਇਕ ਸੀ ਅਤੇ ਅਸੀਂ ਉਠਾਏ ਗਏ ਕੁਝ ਮੁੱਦਿਆਂ ਨੂੰ ਹੱਲ ਕਰਨ ਲਈ ਕੰਮ ਕਰਨਾ ਜਾਰੀ ਰੱਖਦੇ ਹਾਂ।

ਸਰੋਤ: www.habr.com