זיהוי שרבוטים מהירה: איך להתיידד עם R, C++ ורשתות עצביות

היי הבר!

בסתיו האחרון אירחה Kaggle תחרות לסיווג תמונות מצוירות ביד, Quick Draw Doodle Recognition, שבה, בין היתר, לקח חלק צוות של מדעני R: ארטם קלבטסובה, מנהל פיליפה и אנדריי אוגורטסוב. לא נתאר את התחרות בפירוט; זה כבר נעשה ב פרסום אחרון.

הפעם זה לא הסתדר עם חקלאות מדליות, אבל נצבר הרבה ניסיון רב ערך, אז אני רוצה לספר לקהילה על כמה מהדברים המעניינים והשימושיים ביותר בקיגל ובעבודה היומיומית. בין הנושאים שנדונו: חיים קשים בלי OpenCV, ניתוח JSON (דוגמאות אלה בוחנות את השילוב של קוד C++ לתוך סקריפטים או חבילות ב-R באמצעות Rcpp), פרמטריזציה של סקריפטים ודוקריזציה של הפתרון הסופי. כל הקוד מההודעה בצורה מתאימה לביצוע זמין ב מאגרים.

תוכן:

1. טען נתונים מ-CSV ביעילות אל MonetDB
2. הכנת קבוצות
3. איטרטורים לפריקת אצוות ממסד הנתונים
4. בחירת ארכיטקטורת מודל
5. פרמטריזציה של סקריפט
6. עיגון של סקריפטים
7. שימוש במספר GPUs ב-Google Cloud
8. במקום מסקנה

1. טען נתונים מ-CSV ביעילות למסד הנתונים של MonetDB

הנתונים בתחרות זו מסופקים לא בצורה של תמונות מוכנות, אלא בצורה של 340 קבצי CSV (קובץ אחד לכל מחלקה) המכילים JSONs עם קואורדינטות נקודות. על ידי חיבור נקודות אלו בקווים, אנו מקבלים תמונה סופית בגודל 256x256 פיקסלים. כמו כן, לכל רשומה יש תווית המציינת אם התמונה זוהתה כהלכה על ידי המסווג ששימש בזמן איסוף מערך הנתונים, קוד בן שתי אותיות של מדינת המגורים של מחבר התמונה, מזהה ייחודי, חותמת זמן ושם מחלקה התואם לשם הקובץ. גרסה פשוטה של ​​הנתונים המקוריים שוקלת בארכיון 7.4 ג'יגה-בייט וכ-20 ג'יגה-בייט לאחר הפריקה, הנתונים המלאים לאחר הפריקה תופסים 240 ג'יגה-בייט. המארגנים דאגו ששתי הגרסאות ישחזרו את אותם ציורים, כלומר הגרסה המלאה מיותרת. בכל מקרה, אחסון של 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 - command 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 טריקים. הראשון היה להפחית את הממדיות של הסוג המאחסן את מזהה התצפית. במערך הנתונים המקורי, הסוג הנדרש לאחסון המזהה הוא 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. ניתוח מספר JSONs המכילים וקטורים של מחרוזות עם קואורדינטות של נקודות.
2. ציור קווים צבעוניים על סמך קואורדינטות של נקודות על תמונה בגודל הנדרש (לדוגמה, 256×256 או 128×128).
3. המרת התמונות המתקבלות לטנזור.

כחלק מהתחרות בין גרעיני Python, הבעיה נפתרה בעיקר באמצעות 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. ndjson לניתוח JSON. הספרייה הזו משמשת ב xtensor באופן אוטומטי אם הוא קיים בפרויקט.

4. RcppThread לארגון עיבוד מרובה הליכי וקטור מ-JSON. השתמש בקבצי הכותרות שסופקו על ידי חבילה זו. מפופולרי יותר RcppParallel בחבילה, בין היתר, מנגנון הפסקת לולאה מובנה.

יש לציין כי xtensor התברר כמתנה משמים: בנוסף לעובדה שיש לו פונקציונליות נרחבת וביצועים גבוהים, התברר שהמפתחים שלו מגיבים למדי וענו על שאלות במהירות ובפירוט. בעזרתם, ניתן היה ליישם טרנספורמציות של מטריצות OpenCV לטנסורי xtensor, וכן דרך לשלב טנסור תמונה תלת מימדית לטנזור 3 מימדי בממד הנכון (האצווה עצמה).

חומרים ללימוד 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. כדי למצוא באופן אוטומטי נתיבים ודגלים, השתמשנו בכלי עזר פופולרי של לינוקס 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-object (מערך רב-ממדי);

• cpp_process_json_vector - עוטף את הפונקציה cpp_process_json_str, המאפשר לך לעבד וקטור מחרוזת במצב ריבוי הליכי.

כדי לצייר קווים מרובי צבעים, נעשה שימוש במודל הצבע HSV, ולאחר מכן המרה ל-RGB. בואו נבדוק את התוצאה:

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

השוואה של מהירות ההטמעות ב-R ו-C++

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

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

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

res_bench[, cols]

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

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

כפי שניתן לראות, העלאת המהירות התבררה כמשמעותית ביותר, ולא ניתן להדביק את קוד C++ על ידי הקבילה לקוד R.

3. איטרטורים לפריקת אצוות ממסד הנתונים

ל-R יש מוניטין ראוי לעיבוד נתונים שמתאים ל-RAM, בעוד ש-Python מתאפיין יותר בעיבוד נתונים איטרטיבי, המאפשר לך ליישם בקלות ובטבעיות חישובים מחוץ לליבה (חישובים באמצעות זיכרון חיצוני). דוגמה קלאסית ורלוונטית עבורנו בהקשר לבעיה המתוארת היא רשתות עצביות עמוקות המאומנות בשיטת הירידה בדרגה עם קירוב של השיפוע בכל שלב באמצעות חלק קטן מהתצפיות, או מיני-אצט.

למסגרות למידה עמוקה שנכתבו ב-Python יש שיעורים מיוחדים שמיישמים איטרטורים על סמך נתונים: טבלאות, תמונות בתיקיות, פורמטים בינארים וכו'. ניתן להשתמש באפשרויות מוכנות או לכתוב משלך למשימות ספציפיות. ב-R נוכל לנצל את כל התכונות של ספריית Python keras עם החלקים האחוריים השונים שלה באמצעות החבילה באותו שם, שבתורה פועלת על גבי החבילה לרשת. זה האחרון ראוי למאמר ארוך נפרד; זה לא רק מאפשר לך להריץ קוד Python מ-R, אלא גם מאפשר לך להעביר אובייקטים בין הפעלות R ו- Python, תוך ביצוע אוטומטי של כל המרות הסוג הדרושות.

נפטרנו מהצורך לאחסן את כל הנתונים ב-RAM באמצעות MonetDBLite, כל עבודת ה"רשת העצבית" תתבצע על ידי הקוד המקורי ב-Python, אנחנו רק צריכים לכתוב איטרטור על הנתונים, מכיוון שאין שום דבר מוכן למצב כזה ב-R או ב-Python. למעשה יש רק שתי דרישות עבורו: עליו להחזיר אצווה בלולאה אינסופית ולשמור את מצבו בין איטרציות (האחרון ב-R מיושם בצורה הפשוטה ביותר באמצעות סגירות). בעבר, נדרש להמיר במפורש מערכי R למערכים numpy בתוך האיטרטור, אבל הגרסה הנוכחית של החבילה keras עושה את זה בעצמה.

האיטרטור לנתוני אימון ותיקוף התברר כדלקמן:

איטרטור לנתוני הדרכה ואימות

train_generator <- function(db_connection = con,
                            samples_index,
                            num_classes = 340,
                            batch_size = 32,
                            scale = 1,
                            color = FALSE,
                            imagenet_preproc = FALSE) {
  # Проверка аргументов
  checkmate::assert_class(con, "DBIConnection")
  checkmate::assert_integerish(samples_index)
  checkmate::assert_count(num_classes)
  checkmate::assert_count(batch_size)
  checkmate::assert_number(scale, lower = 0.001, upper = 5)
  checkmate::assert_flag(color)
  checkmate::assert_flag(imagenet_preproc)

  # Перемешиваем, чтобы брать и удалять использованные индексы батчей по порядку
  dt <- data.table::data.table(id = sample(samples_index))
  # Проставляем номера батчей
  dt[, batch := (.I - 1L) %/% batch_size + 1L]
  # Оставляем только полные батчи и индексируем
  dt <- dt[, if (.N == batch_size) .SD, keyby = batch]
  # Устанавливаем счётчик
  i <- 1
  # Количество батчей
  max_i <- dt[, max(batch)]

  # Подготовка выражения для выгрузки
  sql <- sprintf(
    "PREPARE SELECT drawing, label_int FROM doodles WHERE id IN (%s)",
    paste(rep("?", batch_size), collapse = ",")
  )
  res <- DBI::dbSendQuery(con, sql)

  # Аналог keras::to_categorical
  to_categorical <- function(x, num) {
    n <- length(x)
    m <- numeric(n * num)
    m[x * n + seq_len(n)] <- 1
    dim(m) <- c(n, num)
    return(m)
  }

  # Замыкание
  function() {
    # Начинаем новую эпоху
    if (i > max_i) {
      dt[, id := sample(id)]
      data.table::setkey(dt, batch)
      # Сбрасываем счётчик
      i <<- 1
      max_i <<- dt[, max(batch)]
    }

    # ID для выгрузки данных
    batch_ind <- dt[batch == i, id]
    # Выгрузка данных
    batch <- DBI::dbFetch(DBI::dbBind(res, as.list(batch_ind)), n = -1)

    # Увеличиваем счётчик
    i <<- i + 1

    # Парсинг JSON и подготовка массива
    batch_x <- cpp_process_json_vector(batch$drawing, scale = scale, color = color)
    if (imagenet_preproc) {
      # Шкалирование c интервала [0, 1] на интервал [-1, 1]
      batch_x <- (batch_x - 0.5) * 2
    }

    batch_y <- to_categorical(batch$label_int, num_classes)
    result <- list(batch_x, batch_y)
    return(result)
  }
}

הפונקציה לוקחת כקלט משתנה עם חיבור למסד הנתונים, מספר השורות בשימוש, מספר המחלקות, גודל אצווה, קנה מידה (scale = 1 מתאים לעיבוד תמונות של 256x256 פיקסלים, scale = 0.5 - 128x128 פיקסלים), מחוון צבע (color = FALSE מציין עיבוד בגווני אפור בעת שימוש color = TRUE כל קו מצויר בצבע חדש) ומחוון עיבוד מקדים לרשתות שהוכשרו מראש ב-imagenet. האחרון נחוץ על מנת לשנות את קנה המידה של ערכי הפיקסלים מהמרווח [0, 1] למרווח [-1, 1], ששימש בעת אימון הציוד שסופק keras מודלים.

הפונקציה החיצונית מכילה בדיקת סוג ארגומנט, טבלה data.table עם מספרי שורה מעורבים באקראי מ samples_index ומספרי אצווה, מונה ומספר אצווה מקסימלי, וכן ביטוי SQL לפריקת נתונים ממסד הנתונים. בנוסף, הגדרנו אנלוגי מהיר של הפונקציה בפנים keras::to_categorical(). השתמשנו כמעט בכל הנתונים לאימון, השארנו חצי אחוז לאימות, כך שגודל העידן הוגבל על ידי הפרמטר steps_per_epoch כשקוראים לו keras::fit_generator(), והמצב if (i > max_i) עבד רק עבור איטרטור האימות.

בפונקציה הפנימית מאחזרים אינדקסים של שורות עבור האצווה הבאה, רשומות נפרקות ממסד הנתונים כאשר מונה האצווה עולה, ניתוח JSON (פונקציה cpp_process_json_vector(), כתוב ב-C++) ויצירת מערכים המתאימים לתמונות. לאחר מכן נוצרים וקטורים חדים עם תוויות מחלקות, מערכים עם ערכי פיקסלים ותוויות משולבים לרשימה, שהיא ערך ההחזרה. כדי להאיץ את העבודה, השתמשנו ביצירת אינדקסים בטבלאות data.table ושינוי דרך הקישור - ללא "שבבי" החבילות הללו טבלת נתונים די קשה לדמיין עבודה יעילה עם כל כמות משמעותית של נתונים ב-R.

התוצאות של מדידות מהירות במחשב נייד Core i5 הן כדלקמן:

רף איטרטור

library(Rcpp)
library(keras)
library(ggplot2)

source("utils/rcpp.R")
source("utils/keras_iterator.R")

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

ind <- seq_len(DBI::dbGetQuery(con, "SELECT count(*) FROM doodles")[[1L]])
num_classes <- DBI::dbGetQuery(con, "SELECT max(label_int) + 1 FROM doodles")[[1L]]

# Индексы для обучающей выборки
train_ind <- sample(ind, floor(length(ind) * 0.995))
# Индексы для проверочной выборки
val_ind <- ind[-train_ind]
rm(ind)
# Коэффициент масштаба
scale <- 0.5

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

#   batch_size      min   median      max `itr/sec` total_time n_itr
#        <dbl> <bch:tm> <bch:tm> <bch:tm>     <dbl>   <bch:tm> <int>
# 1         16     25ms  64.36ms   92.2ms     15.9       3.09s    49
# 2         32   48.4ms 118.13ms 197.24ms     8.17       5.88s    48
# 3         64   69.3ms 117.93ms 181.14ms     8.57       5.83s    50
# 4        128  157.2ms 240.74ms 503.87ms     3.85      12.71s    49
# 5        256  359.3ms 613.52ms 988.73ms     1.54       30.5s    47
# 6        512  884.7ms    1.53s    2.07s     0.674      1.11m    45
# 7       1024     2.7s    3.83s    5.47s     0.261      2.81m    44

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

DBI::dbDisconnect(con, shutdown = TRUE)

אם יש לך כמות מספקת של זיכרון RAM, אתה יכול להאיץ ברצינות את פעולת מסד הנתונים על ידי העברתו לאותו זיכרון RAM (32 ג'יגה-בייט מספיקים למשימה שלנו). ב-Linux, המחיצה מותקנת כברירת מחדל /dev/shm, תופס עד מחצית מקיבולת ה-RAM. אתה יכול להדגיש עוד על ידי עריכה /etc/fstabכדי לקבל תקליט כמו tmpfs /dev/shm tmpfs defaults,size=25g 0 0. הקפד לאתחל ולבדוק את התוצאה על ידי הפעלת הפקודה df -h.

האיטרטור לנתוני בדיקה נראה הרבה יותר פשוט, מכיוון שמערך הנתונים של הבדיקה מתאים לחלוטין ל-RAM:

איטרטור לנתוני בדיקה

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

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

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

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

4. בחירת ארכיטקטורת המודל

הארכיטקטורה הראשונה שבה נעשה שימוש הייתה mobilenet v1, שתכונותיו נדונות ב זה הוֹדָעָה. זה כלול כסטנדרט keras ובהתאם, זמין בחבילה באותו שם עבור R. אבל כשמנסים להשתמש בו עם תמונות חד-ערוציות, התברר דבר מוזר: טנזור הקלט חייב תמיד להיות בעל הממד (batch, height, width, 3), כלומר, לא ניתן לשנות את מספר הערוצים. אין מגבלה כזו ב-Python, אז מיהרנו וכתבנו יישום משלנו של הארכיטקטורה הזו, בעקבות המאמר המקורי (ללא הנשירה שנמצאת בגרסת ה-keras):

ארכיטקטורת Mobilenet v1

library(keras)

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

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

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

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

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

  inputs <- layer_input(shape = input_shape)

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

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

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

    return(model)
}

החסרונות של גישה זו ברורים. אני רוצה לבדוק הרבה דגמים, אבל להיפך, אני לא רוצה לשכתב כל ארכיטקטורה באופן ידני. גם נשללה מאיתנו ההזדמנות להשתמש במשקלים של דוגמניות שהוכשרו מראש באימג'נט. כרגיל, לימוד התיעוד עזר. פוּנקצִיָה get_config() מאפשר לך לקבל תיאור של הדגם בצורה מתאימה לעריכה (base_model_conf$layers - רשימת R רגילה), והפונקציה from_config() מבצע את ההמרה ההפוכה לאובייקט מודל:

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

עכשיו זה לא קשה לכתוב פונקציה אוניברסלית כדי להשיג כל אחד מהדברים שסופקו keras דגמים עם או בלי משקולות מאומנות ב-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 מהגרסה הנוכחית keras בשימוש R לא יכול עקב שינויים שלא נלקחו בחשבון בחבילת R, אנו מחכים שיתקנו זאת.

גישה זו אפשרה לזרז משמעותית ניסויים עם דגמים שונים בהשוואה להשקה המסורתית יותר של סקריפטים ב-RStudio (אנו מציינים את החבילה כחלופה אפשרית tfruns). אבל היתרון העיקרי הוא היכולת לנהל בקלות את ההשקה של סקריפטים ב-Docker או פשוט בשרת, מבלי להתקין RStudio בשביל זה.

6. עגינה של סקריפטים

השתמשנו ב-Docker כדי להבטיח ניידות של הסביבה לאימון מודלים בין חברי צוות ולפריסה מהירה בענן. אתה יכול להתחיל להכיר את הכלי הזה, שהוא יחסית חריג למתכנת R זה סדרת פרסומים או קורס וידאו.

Docker מאפשר לך גם ליצור תמונות משלך מאפס וגם להשתמש בתמונות אחרות כבסיס ליצירת תמונות משלך. בעת ניתוח האפשרויות הזמינות, הגענו למסקנה שהתקנת מנהלי התקנים של NVIDIA, CUDA+cuDNN וספריות Python היא חלק די נרחב מהתמונה, והחלטנו לקחת את התמונה הרשמית כבסיס tensorflow/tensorflow:1.12.0-gpu, הוספת שם את חבילות ה-R הדרושות.

קובץ הדוקר הסופי נראה כך:

דוקרפיל

FROM tensorflow/tensorflow:1.12.0-gpu

MAINTAINER Artem Klevtsov <[email protected]>

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

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

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

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

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

WORKDIR /app

VOLUME /db
VOLUME /app

CMD bash

מטעמי נוחות, החבילות בהן נעשה שימוש הוכנסו למשתנים; רוב התסריטים הכתובים מועתקים בתוך המיכלים במהלך ההרכבה. שינינו גם את מעטפת הפקודה ל /bin/bash לנוחות השימוש בתוכן /etc/os-release. זה נמנע מהצורך לציין את גרסת מערכת ההפעלה בקוד.

בנוסף, נכתב סקריפט 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. שימוש במספר GPUs ב-Google Cloud

אחד המאפיינים של התחרות היה הנתונים הרועשים מאוד (ראה את תמונת הכותרת, שהושאלה מ[email protected] מ-ODS slack). אצוות גדולות עוזרות להילחם בזה, ולאחר ניסויים במחשב עם 1 GPU, החלטנו לשלוט במודלים של אימון במספר GPUs בענן. השתמש ב-GoogleCloud (מדריך טוב ליסודות) בשל המבחר הגדול של תצורות זמינות, מחירים סבירים ובונוס של $300. מתוך חמדנות, הזמנתי מופע 4xV100 עם SSD והרבה זיכרון RAM, וזו הייתה טעות גדולה. מכונה כזו גוזלת כסף במהירות; אתה יכול לצאת לניסויים ללא צינור מוכח. למטרות חינוכיות, עדיף לקחת את K80. אבל הכמות הגדולה של זיכרון RAM הועילה - ה-SSD בענן לא הרשים בביצועים שלו, ולכן מסד הנתונים הועבר אל dev/shm.

המעניין ביותר הוא קטע הקוד שאחראי לשימוש במספר GPUs. ראשית, המודל נוצר על ה-CPU באמצעות מנהל הקשר, בדיוק כמו ב-Python:

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

ואז המודל הלא-קומפילציה (זה חשוב) מועתק למספר נתון של GPUs זמינים, ורק לאחר מכן הוא הידור:

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

לא ניתן היה ליישם את הטכניקה הקלאסית של הקפאת כל השכבות מלבד האחרונה, אימון השכבה האחרונה, ביטול הקפאה ואימון מחדש של הדגם כולו למספר 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. במקום מסקנה

עדיין לא התגברו על מספר בעיות שנתקלנו בהן:

• в keras אין פונקציה מוכנה לחיפוש אוטומטי אחר קצב הלמידה האופטימלי (אנלוגי lr_finder בספריה מהר.אי); עם קצת מאמץ, אפשר להעביר יישומי צד שלישי ל-R, למשל, זה;
• כתוצאה מהנקודה הקודמת, לא ניתן היה לבחור את מהירות האימון הנכונה בעת שימוש במספר GPUs;
• יש חוסר בארכיטקטורות מודרניות של רשתות עצביות, במיוחד אלו שהוכשרו מראש ב-imagenet;
• אין מדיניות של מחזור אחד ושיעורי למידה מפלים (חישול קוסינוס היה לבקשתנו מוטמעתודה סקיידן).

אילו דברים שימושיים נלמדו מהתחרות הזו:

• על חומרה בעלת הספק נמוך יחסית, אתה יכול לעבוד עם נפחי נתונים הגונים (פי רבים מ-RAM) ללא כאב. שקית פלסטיק טבלת נתונים חוסך זיכרון עקב שינוי במקום של טבלאות, מה שנמנע מהעתקתן, ובשימוש נכון, היכולות שלו כמעט תמיד מדגימות את המהירות הגבוהה ביותר מבין כל הכלים המוכרים לנו לשפות סקריפטים. שמירת נתונים במסד נתונים מאפשרת לך, במקרים רבים, לא לחשוב כלל על הצורך לסחוט את כל מערך הנתונים לתוך ה-RAM.
• ניתן להחליף פונקציות איטיות ב-R במהירות ב-C++ באמצעות החבילה Rcpp. אם בנוסף לשימוש RcppThread או RcppParallel, אנו מקבלים מימושים עם ריבוי הליכי חוצה פלטפורמות, כך שאין צורך להקביל את הקוד ברמת R.
• חֲבִילָה Rcpp ניתן להשתמש ללא ידע רציני ב-C++, המינימום הנדרש מתואר כאן. קבצי כותרות למספר ספריות C מגניבות כמו xtensor זמין ב-CRAN, כלומר נוצרת תשתית ליישום פרויקטים המשלבים קוד C++ מוכן ומוכן עם ביצועים גבוהים לתוך R. נוחות נוספת היא הדגשת תחביר ומנתח קוד C++ סטטי ב-RStudio.
• דוקופט מאפשר לך להריץ סקריפטים עצמאיים עם פרמטרים. זה נוח לשימוש בשרת מרוחק, כולל. תחת דוקר. ב-RStudio לא נוח לערוך שעות רבות של ניסויים באימון רשתות עצביות, והתקנת ה-IDE על השרת עצמו לא תמיד מוצדקת.
• Docker מבטיח ניידות קוד ושחזור של תוצאות בין מפתחים עם גרסאות שונות של מערכת ההפעלה והספריות, כמו גם קלות ביצוע בשרתים. אתה יכול להפעיל את כל צינור האימונים עם פקודה אחת בלבד.
• Google Cloud היא דרך ידידותית לתקציב להתנסות בחומרה יקרה, אך עליך לבחור תצורות בקפידה.
• מדידת מהירות של קטעי קוד בודדים היא שימושית מאוד, במיוחד בשילוב R ו-C++, ועם החבילה ספסל - גם קל מאוד.

בסך הכל החוויה הזו הייתה מתגמלת מאוד ואנחנו ממשיכים לעבוד כדי לפתור כמה מהבעיות שהועלו.

מקור: www.habr.com