เชนเซ เชนเชฌเชฐ!
เชเซเชฒเซเชฒเชพ เชชเชพเชจเชเชฐเชฎเชพเช, เชเชพเชเชฒเซ เชนเชพเชฅเชฅเซ เชฆเซเชฐเซเชฒเชพ เชเชฟเชคเซเชฐเซเชจเซ เชตเชฐเซเชเซเชเซเชค เชเชฐเชตเชพ เชฎเชพเชเซ เชเช เชธเซเชชเชฐเซเชงเชพเชจเซเช เชเชฏเซเชเชจ เชเชฐเซเชฏเซเช เชนเชคเซเช, เชเซเชตเชฟเช เชกเซเชฐเซ เชกเซเชกเชฒ เชฐเซเชเชเซเชจเชฟเชถเชจ, เชเซเชฎเชพเช เช
เชจเซเชฏเซ เชตเชเซเชเซ, เชเชฐ-เชตเซเชเซเชเชพเชจเชฟเชเซเชจเซ เชเซเชฎเซ เชญเชพเช เชฒเซเชงเซ เชนเชคเซ:
เช เชตเชเชคเซ เชคเซ เชฎเซเชกเชฒ เชซเชพเชฐเซเชฎเชฟเชเช เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเซ เชถเชเซเชฏเซเช เชจเชฅเซ, เชชเชฐเชเชคเซ เชเชฃเซ เชฎเซเชฒเซเชฏเชตเชพเชจ เช
เชจเซเชญเชต เชฎเซเชณเชตเซเชฏเซ เชนเชคเซ, เชคเซเชฅเซ เชนเซเช เชธเชฎเซเชฆเชพเชฏเชจเซ เชเชพเชเชฒเซ เช
เชจเซ เชฐเซเชเชฟเชเชฆเชพ เชเชพเชฎเชฎเชพเช เชเชฃเซ เชฌเชงเซ เชฐเชธเชชเซเชฐเชฆ เช
เชจเซ เชเชชเชฏเซเชเซ เชตเชธเซเชคเซเช เชตเชฟเชถเซ เชเชฃเชพเชตเชตเชพ เชฎเชพเชเชเซ เชเซเช. เชเชฐเซเชเชพ เชเชฐเซเชฒเชพ เชตเชฟเชทเชฏเซเชฎเชพเช: เชตเชฟเชจเชพ เชฎเซเชถเซเชเซเชฒ เชเซเชตเชจ เชเชชเชจเชธเซเชตเซ, JSON เชชเชฆเชเซเชเซเชฆเชจ (เช เชเชฆเชพเชนเชฐเชฃเซ R เชฎเชพเช เชธเซเชเซเชฐเชฟเชชเซเชเซ เช
เชฅเชตเชพ เชชเซเชเซเชเซเชฎเชพเช C++ เชเซเชกเชจเชพ เชเชเซเชเชฐเชฃเชจเซ เชคเชชเชพเชธ เชเชฐเซ เชเซ. เชเชฐเชธเซเชชเซเชชเซ), เชธเซเชเซเชฐเชฟเชชเซเชเซเชธเชจเซเช เชชเซเชฐเชพเชฎเซเชเชฐเชพเชเชเซเชถเชจ เช
เชจเซ เช
เชเชคเชฟเชฎ เชธเซเชฒเซเชฏเซเชถเชจเชจเซเช เชกเซเชเชฐเชพเชเชเซเชถเชจ. เชเชเซเชเซเชเซเชฏเซเชถเชจ เชฎเชพเชเซ เชฏเซเชเซเชฏ เชซเซเชฐเซเชฎเชฎเชพเช เชฎเซเชธเซเชเชฎเชพเชเชฅเซ เชคเชฎเชพเชฎ เชเซเชก เชเชชเชฒเชฌเซเชง เชเซ
เช เชจเซเชเซเชฐเชฎเชฃเชฟเชเชพ:
เชฎเซเชจเซเชเชกเซเชฌเซเชฎเชพเช CSVเชฎเชพเชเชฅเซ เชกเซเชเชพเชจเซ เช เชธเชฐเชเชพเชฐเช เชฐเซเชคเซ เชฒเซเชก เชเชฐเซ เชฌเซเช เชคเซเชฏเชพเชฐ เชเชฐเซ เชฐเชนเซเชฏเชพ เชเซเช เชกเซเชเชพเชฌเซเชเชฎเชพเชเชฅเซ เชฌเซเชเชจเซ เช เชจเชฒเซเชก เชเชฐเชตเชพ เชฎเชพเชเซ เชชเซเชจเชฐเชพเชตเชฐเซเชคเชเซ เชเช เชฎเซเชกเซเชฒ เชเชฐเซเชเชฟเชเซเชเซเชเชฐ เชชเชธเชเชฆ เชเชฐเซ เชฐเชนเซเชฏเชพ เชเซเช เชธเซเชเซเชฐเชฟเชชเซเช เชชเซเชฐเชพเชฎเซเชเชฐเชพเชเชเซเชถเชจ เชธเซเชเซเชฐเชฟเชชเซเชเซเชจเซเช เชกเซเชเชฐเชพเชเชเซเชถเชจ Google Cloud เชชเชฐ เชฌเชนเซเชตเชฟเชง GPU เชจเซ เชเชชเชฏเซเช เชเชฐเชตเซ เชคเซเชจเชพ เชฌเชฆเชฒเซ เชเช เชจเชฟเชทเซเชเชฐเซเชท
1. เชฎเซเชจเซเชเชกเซเชฌเซ เชกเซเชเชพเชฌเซเชเชฎเชพเช CSVเชฎเชพเชเชฅเซ เชกเซเชเชพเชจเซ เช เชธเชฐเชเชพเชฐเช เชฐเซเชคเซ เชฒเซเชก เชเชฐเซ
เช เชธเซเชชเชฐเซเชงเชพเชจเซ เชกเซเชเชพ เชคเซเชฏเชพเชฐ เชเชฎเซเชเชจเชพ เชฐเซเชชเชฎเชพเช เชจเชนเซเช, เชชเชฐเชเชคเซ เชชเซเชเชจเซเช เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชธเชพเชฅเซ JSON เชงเชฐเชพเชตเชคเซ 340 CSV เชซเชพเชเชฒเซ (เชฆเชฐเซเช เชตเชฐเซเช เชฎเชพเชเซ เชเช เชซเชพเชเชฒ)เชจเชพ เชฐเซเชชเชฎเชพเช เชชเซเชฐเชฆเชพเชจ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชเซ. เช เชฌเชฟเชเชฆเซเชเชจเซ เชฐเซเชเชพเช เชธเชพเชฅเซ เชเซเชกเซเชจเซ, เช เชฎเชจเซ 256x256 เชชเชฟเชเซเชธเซเชฒ เชฎเชพเชชเชตเชพเชจเซ เช เชเชคเชฟเชฎ เชเชฌเซ เชฎเชณเซ เชเซ. เชคเซเชฎเช เชฆเชฐเซเช เชฐเซเชเซเชฐเซเชก เชฎเชพเชเซ เชเช เชฒเซเชฌเชฒ เชเซ เชเซ เชฆเชฐเซเชถเชพเชตเซ เชเซ เชเซ เชกเซเชเชพเชธเซเช เชเชเชคเซเชฐเชฟเชค เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชคเซ เชธเชฎเชฏเซ เชเชชเชฏเซเชเชฎเชพเช เชฒเซเชตเชพเชคเชพ เชตเชฐเซเชเซเชเซเชค เชฆเซเชตเชพเชฐเชพ เชเชฟเชคเซเชฐเชจเซ เชฏเซเชเซเชฏ เชฐเซเชคเซ เชเชณเชเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช เชเซ เชจเชนเซเช, เชเชฟเชคเซเชฐเชจเชพ เชฒเซเชเชเชจเชพ เชฐเชนเซเช เชพเชฃเชจเชพ เชฆเซเชถเชจเซ เชฌเซ-เช เชเซเชทเชฐเชจเซ เชเซเชก, เชเช เช เชจเชจเซเชฏ เชเชณเชเชเชฐเซเชคเชพ, เชเชพเชเชฎเชธเซเชเซเชฎเซเชช. เช เชจเซ เชตเชฐเซเชเชจเซเช เชจเชพเชฎ เชเซ เชซเชพเชเชฒเชจเชพ เชจเชพเชฎ เชธเชพเชฅเซ เชฎเซเชณ เชเชพเชฏ เชเซ. เชฎเซเชณ เชกเซเชเชพเชจเชพ เชธเชฐเชณ เชธเชเชธเซเชเชฐเชฃเชจเซเช เชตเชเชจ เชเชฐเซเชเชพเชเชตเชฎเชพเช 7.4 GB เชนเซเชฏ เชเซ เช เชจเซ เช เชจเชชเซเช เชเชฐเซเชฏเชพ เชชเชเซ เชเชถเชฐเซ 20 GB เชนเซเชฏ เชเซ, เช เชจเชชเซ เช เชเชฐเซเชฏเชพ เชชเชเซ เชธเชเชชเซเชฐเซเชฃ เชกเซเชเชพ 240 GB เชฒเซ เชเซ. เชเชฏเซเชเชเซเช เชธเซเชจเชฟเชถเซเชเชฟเชค เชเชฐเซเชฏเซเช เชเซ เชฌเชเชจเซ เชธเชเชธเซเชเชฐเชฃเซ เชธเชฎเชพเชจ เชฐเซเชเชพเชเชเชจเซเชจเซเช เชชเซเชจเชเชเชคเซเชชเชพเชฆเชจ เชเชฐเซ เชเซ, เชเชเชฒเซ เชเซ เชธเชเชชเซเชฐเซเชฃ เชธเชเชธเซเชเชฐเชฃ เชจเชฟเชฐเชฐเซเชฅเช เชนเชคเซเช. เชเซเช เชชเชฃ เชธเชเชเซเชเซเชฎเชพเช, เชเซเชฐเชพเชซเชฟเช เชซเชพเชเชฒเซเชฎเชพเช เช เชฅเชตเชพ เชเชฐเซเชจเชพ เชธเซเชตเชฐเซเชชเชฎเชพเช 50 เชฎเชฟเชฒเชฟเชฏเชจ เชเชฎเซเชเซ เชธเชเชเซเชฐเชนเชฟเชค เชเชฐเชตเชพเชจเซเช เชคเชฐเชค เช เชฌเชฟเชจเชฒเชพเชญเชเชพเชฐเซ เชฎเชพเชจเชตเชพเชฎเชพเช เชเชตเชคเซเช เชนเชคเซเช, เช เชจเซ เช เชฎเซ เชเชฐเซเชเชพเชเชตเชฎเชพเชเชฅเซ เชฌเชงเซ CSV เชซเชพเชเชฒเซเชจเซ เชฎเชฐเซเช เชเชฐเชตเชพเชจเซเช เชจเชเซเชเซ เชเชฐเซเชฏเซเช. train_simplified.zip เชฆเชฐเซเช เชฌเซเช เชฎเชพเชเซ "เชซเซเชฒเชพเชฏ เชชเชฐ" เชเชฐเซเชฐเซ เชเชฆเชจเซ เชเชฌเซเชเชจเซ เช เชจเซเชเชพเชฎเซ เชชเซเชขเซ เชธเชพเชฅเซ เชกเซเชเชพเชฌเซเชเชฎเชพเช.
DBMS เชคเชฐเซเชเซ เชธเชพเชฐเซ เชฐเซเชคเซ เชธเชพเชฌเชฟเชค เชธเชฟเชธเซเชเชฎ เชชเชธเชเชฆ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชนเชคเซ เชฎเซเชจเซเชเชกเซเชฌเซ, เชเชเชฒเซ เชเซ เชชเซเชเซเช เชคเชฐเซเชเซ R เชฎเชพเชเซ เช
เชฎเชฒเซเชเชฐเชฃ
con <- DBI::dbConnect(drv = MonetDBLite::MonetDBLite(), Sys.getenv("DBDIR"))
เช เชฎเชพเชฐเซ เชฌเซ เชเซเชทเซเชเชเซ เชฌเชจเชพเชตเชตเชพเชจเซ เชเชฐเซเชฐ เชชเชกเชถเซ: เชเช เชคเชฎเชพเชฎ เชกเซเชเชพ เชฎเชพเชเซ, เชฌเซเชเซเช เชกเชพเชเชจเชฒเซเชก เชเชฐเซเชฒเซ เชซเชพเชเชฒเซ เชตเชฟเชถเซเชจเซ เชธเซเชตเชพเชจเซ เชฎเชพเชนเชฟเชคเซ เชฎเชพเชเซ (เชเซ เชเชเชเช เชเซเชเซเช เชฅเชพเชฏ เชคเซ เชเชชเชฏเซเชเซ เชเซ เช เชจเซ เชเชฃเซ เชซเชพเชเชฒเซ เชกเชพเชเชจเชฒเซเชก เชเชฐเซเชฏเชพ เชชเชเซ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชซเชฐเซ เชถเชฐเซ เชเชฐเชตเซ เชชเชกเชถเซ):
เชเซเชทเซเชเชเซ เชฌเชจเชพเชตเซ เชฐเชนเซเชฏเชพ เชเซเช
if (!DBI::dbExistsTable(con, "doodles")) {
DBI::dbCreateTable(
con = con,
name = "doodles",
fields = c(
"countrycode" = "char(2)",
"drawing" = "text",
"key_id" = "bigint",
"recognized" = "bool",
"timestamp" = "timestamp",
"word" = "text"
)
)
}
if (!DBI::dbExistsTable(con, "upload_log")) {
DBI::dbCreateTable(
con = con,
name = "upload_log",
fields = c(
"id" = "serial",
"file_name" = "text UNIQUE",
"uploaded" = "bool DEFAULT false"
)
)
}
เชกเซเชเชพเชฌเซเชเชฎเชพเช เชกเซเชเชพ เชฒเซเชก เชเชฐเชตเชพเชจเซ เชธเซเชฅเซ เชเชกเชชเซ เชฐเซเชค SQL - เชเชฆเซเชถเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ CSV เชซเชพเชเชฒเซเชจเซ เชธเซเชงเซ เชจเชเชฒ เชเชฐเชตเชพเชจเซ เชนเชคเซ COPY OFFSET 2 INTO tablename FROM path USING DELIMITERS ',','n','"' NULL AS '' BEST EFFORT
เชเซเชฏเชพเช tablename
- เชเซเชฌเชฒเชจเซเช เชจเชพเชฎ เช
เชจเซ path
- เชซเชพเชเชฒเชจเซ เชฎเชพเชฐเซเช. เชเชฐเซเชเชพเชเชต เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเชคเซ เชตเชเชคเซ, เชเชตเซเช เชเชพเชฃเชตเชพ เชฎเชณเซเชฏเซเช เชนเชคเซเช เชเซ เชฌเชฟเชฒเซเช-เชเชจ เช
เชฎเชฒเซเชเชฐเชฃ unzip
เชเชฐ เชฎเชพเช เชเชฐเซเชเชพเชเชตเชฎเชพเชเชฅเซ เชธเชเชเซเชฏเชพเชฌเชเชง เชซเชพเชเชฒเซ เชธเชพเชฅเซ เชฏเซเชเซเชฏ เชฐเซเชคเซ เชเชพเชฎ เชเชฐเชคเซเช เชจเชฅเซ, เชคเซเชฅเซ เช
เชฎเซ เชธเชฟเชธเซเชเชฎเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ 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. เชฌเซเช เชคเซเชฏเชพเชฐ เชเชฐเซ เชฐเชนเซเชฏเชพ เชเซเช
เชธเชฎเชเซเชฐ เชฌเซเช เชคเซเชฏเชพเชฐ เชเชฐเชตเชพเชจเซ เชชเซเชฐเชเซเชฐเชฟเชฏเชพเชฎเชพเช เชจเซเชเซเชจเชพ เชชเชเชฒเชพเชเช เชถเชพเชฎเซเชฒ เชเซ:
- เชชเซเชเชจเซเชเชจเชพ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชธเชพเชฅเซ เชธเซเชเซเชฐเชฟเชเชเซเชธเชจเชพ เชตเซเชเซเชเชฐ เชงเชฐเชพเชตเชคเชพ เชเชฃเชพ JSON เชจเซ เชชเชพเชฐเซเชธเชฟเชเช.
- เชเชฐเซเชฐเซ เชเชฆเชจเซ เชเชฌเซ เชชเชฐ เชฌเชฟเชเชฆเซเชเชจเชพ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธ เชชเชฐ เชเชงเชพเชฐเชฟเชค เชฐเชเชเซเชจ เชฐเซเชเชพเช เชฆเซเชฐเชตเซ (เชเชฆเชพเชนเชฐเชฃ เชคเชฐเซเชเซ, 256ร256 เช เชฅเชตเชพ 128ร128).
- เชชเชฐเชฟเชฃเชพเชฎเซ เชเชฌเซเชเชจเซ เชเซเชจเซเชธเชฐเชฎเชพเช เชฐเซเชชเชพเชเชคเชฐเชฟเชค เชเชฐเชตเซ.
เชชเชพเชฏเชฅเซเชจ เชเชฐเซเชจเชฒเซ เชตเชเซเชเซเชจเซ เชธเซเชชเชฐเซเชงเชพเชจเชพ เชญเชพเช เชฐเซเชชเซ, เชธเชฎเชธเซเชฏเชพเชจเซ เชเชเซเชฒ เชฎเซเชเซเชฏเชคเซเชตเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชนเชคเซ เชเชชเชจเชธเซเชตเซ. R เชฎเชพเช เชธเซเชฅเซ เชธเชฐเชณ เช เชจเซ เชธเซเชฅเซ เชธเซเชชเชทเซเช เชเชจเชพเชฒเซเช เชเชจเชพ เชเซเชตเซ เชฆเซเชเชพเชถเซ:
R เชฎเชพเช JSON เชฅเซ เชเซเชจเซเชธเชฐ เชฐเซเชชเชพเชเชคเชฐเชฃเชจเซ เช เชฎเชฒ
r_process_json_str <- function(json, line.width = 3,
color = TRUE, scale = 1) {
# ะะฐััะธะฝะณ JSON
coords <- jsonlite::fromJSON(json, simplifyMatrix = FALSE)
tmp <- tempfile()
# ะฃะดะฐะปัะตะผ ะฒัะตะผะตะฝะฝัะน ัะฐะนะป ะฟะพ ะทะฐะฒะตััะตะฝะธั ััะฝะบัะธะธ
on.exit(unlink(tmp))
png(filename = tmp, width = 256 * scale, height = 256 * scale, pointsize = 1)
# ะัััะพะน ะณัะฐัะธะบ
plot.new()
# ะ ะฐะทะผะตั ะพะบะฝะฐ ะณัะฐัะธะบะฐ
plot.window(xlim = c(256 * scale, 0), ylim = c(256 * scale, 0))
# ะฆะฒะตัะฐ ะปะธะฝะธะน
cols <- if (color) rainbow(length(coords)) else "#000000"
for (i in seq_along(coords)) {
lines(x = coords[[i]][[1]] * scale, y = coords[[i]][[2]] * scale,
col = cols[i], lwd = line.width)
}
dev.off()
# ะัะตะพะฑัะฐะทะพะฒะฐะฝะธะต ะธะทะพะฑัะฐะถะตะฝะธั ะฒ 3-ั
ะผะตัะฝัะน ะผะฐััะธะฒ
res <- png::readPNG(tmp)
return(res)
}
r_process_json_vector <- function(x, ...) {
res <- lapply(x, r_process_json_str, ...)
# ะะฑัะตะดะธะฝะตะฝะธะต 3-ั
ะผะตัะฝัั
ะผะฐััะธะฒะพะฒ ะบะฐััะธะฝะพะบ ะฒ 4-ั
ะผะตัะฝัะน ะฒ ัะตะฝะทะพั
res <- do.call(abind::abind, c(res, along = 0))
return(res)
}
เชกเซเชฐเซเชเชเช เชชเซเชฐเชฎเชพเชฃเชญเซเชค R เชธเชพเชงเชจเซเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชเซ เช
เชจเซ RAM เชฎเชพเช เชธเชเชเซเชฐเชนเชฟเชค เชเชพเชฎเชเชฒเชพเช PNG เชฎเชพเช เชธเชพเชเชตเชตเชพเชฎเชพเช เชเชตเซ เชเซ (เชฒเชฟเชจเชเซเชธ เชชเชฐ, เช
เชธเซเชฅเชพเชฏเซ R เชกเชฟเชฐเซเชเซเชเชฐเซเช เชกเชฟเชฐเซเชเซเชเชฐเซเชฎเชพเช เชธเซเชฅเชฟเชค เชเซ. /tmp
, RAM เชฎเชพเช เชฎเชพเชเชจเซเช เชฅเชฏเซเชฒ เชเซ). เช เชซเชพเชเชฒ เชชเชเซ 0 เชฅเซ 1 เชธเซเชงเซเชจเซ เชธเชเชเซเชฏเชพเช เชธเชพเชฅเซ เชคเซเชฐเชฟ-เชชเชฐเชฟเชฎเชพเชฃเซเชฏ เชเชฐเซ เชคเชฐเซเชเซ เชตเชพเชเชเชตเชพเชฎเชพเช เชเชตเซ เชเซ. เช เชฎเชนเชคเซเชตเชชเซเชฐเซเชฃ เชเซ เชเชพเชฐเชฃ เชเซ เชตเชงเซ เชชเชฐเชเชชเชฐเชพเชเชค BMP เชนเซเชเซเชธ เชเชฒเชฐ เชเซเชกเซเชธ เชธเชพเชฅเซ เชเชพเชเชพ เชเชฐเซเชฎเชพเช เชตเชพเชเชเชตเชพเชฎเชพเช เชเชตเชถเซ.
เชเชพเชฒเซ เชชเชฐเชฟเชฃเชพเชฎเชจเซเช เชชเชฐเซเชเซเชทเชฃ เชเชฐเซเช:
zip_file <- file.path("data", "train_simplified.zip")
csv_file <- "cat.csv"
unzip(zip_file, files = csv_file, exdir = tempdir(),
junkpaths = TRUE, unzip = getOption("unzip"))
tmp_data <- data.table::fread(file.path(tempdir(), csv_file), sep = ",",
select = "drawing", nrows = 10000)
arr <- r_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256 3
plot(magick::image_read(arr))
เชฌเซเช เชชเซเชคเซ เชจเซเชเซ เชชเซเชฐเชฎเชพเชฃเซ เชฐเชเชตเชพเชฎเชพเช เชเชตเชถเซ:
res <- r_process_json_vector(tmp_data[1:4, drawing], scale = 0.5)
str(res)
# num [1:4, 1:128, 1:128, 1:3] 1 1 1 1 1 1 1 1 1 1 ...
# - attr(*, "dimnames")=List of 4
# ..$ : NULL
# ..$ : NULL
# ..$ : NULL
# ..$ : NULL
เช เช เชฎเชฒเซเชเชฐเชฃ เช เชฎเชจเซ เช เชฏเซเชเซเชฏ เชฒเชพเชเชคเซเช เชนเชคเซเช, เชเชพเชฐเชฃ เชเซ เชฎเซเชเซ เชฌเซเชเชจเซ เชฐเชเชจเชพเชฎเชพเช เช เชฏเซเชเซเชฏ เชฐเซเชคเซ เชฒเชพเชเชฌเซ เชธเชฎเชฏ เชฒเชพเชเซ เชเซ, เช เชจเซ เช เชฎเซ เชถเชเซเชคเชฟเชถเชพเชณเซ เชชเซเชธเซเชคเชเชพเชฒเชฏเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เช เชฎเชพเชฐเชพ เชธเชพเชฅเซเชฆเชพเชฐเซเชจเชพ เช เชจเซเชญเชตเชจเซ เชฒเชพเชญ เชฒเซเชตเชพเชจเซเช เชจเชเซเชเซ เชเชฐเซเชฏเซเช. เชเชชเชจเชธเซเชตเซ. เชคเซ เชธเชฎเชฏเซ R เชฎเชพเชเซ เชเซเช เชคเซเชฏเชพเชฐ เชชเซเชเซเช เชจเชนเซเชคเซเช (เชนเชตเซ เชเซเช เชจเชฅเซ), เชคเซเชฅเซ เชเชฐเซเชฐเซ เชเชพเชฐเซเชฏเชเซเชทเชฎเชคเชพเชจเซเช เชจเซเชฏเซเชจเชคเชฎ เช เชฎเชฒเซเชเชฐเชฃ C++ เชฎเชพเช R เชเซเชกเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเชเซเชเชฐเชฃ เชธเชพเชฅเซ เชฒเชเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช. เชเชฐเชธเซเชชเซเชชเซ.
เชธเชฎเชธเซเชฏเชพ เชนเชฒ เชเชฐเชตเชพ เชฎเชพเชเซ, เชจเซเชเซเชจเชพ เชชเซเชเซเชเซ เช เชจเซ เชชเซเชธเซเชคเชเชพเชฒเชฏเซเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชนเชคเซ:
-
เชเชชเชจเชธเซเชตเซ เชเชฌเซเช เช เชจเซ เชฐเซเชเชพเชเชเชจ เชฐเซเชเชพเช เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเชตเชพ เชฎเชพเชเซ. เชชเซเชฐเซ-เชเชจเซเชธเซเชเซเชฒ เชเชฐเซเชฒเซ เชธเชฟเชธเซเชเชฎ เชฒเชพเชเชฌเซเชฐเซเชฐเซเช เช เชจเซ เชนเซเชกเชฐ เชซเชพเชเชฒเซ เชคเซเชฎเช เชกเชพเชฏเชจเซเชฎเชฟเช เชฒเชฟเชเชเชฟเชเชเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ.
-
xtensor เชฌเชนเซเชชเชฐเซเชฎเชพเชฃเซเชฏ เชเชฐเซ เช เชจเซ เชเซเชจเซเชธเชฐเซเชธ เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเชตเชพ เชฎเชพเชเซ. เช เชฎเซ เชธเชฎเชพเชจ เชจเชพเชฎเชจเชพ R เชชเซเชเซเชเชฎเชพเช เชธเชฎเชพเชตเชฟเชทเซเช เชนเซเชกเชฐ เชซเชพเชเชฒเซเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ เชเซ. เชฒเชพเชเชฌเซเชฐเซเชฐเซ เชคเชฎเชจเซ เชฌเชนเซเชชเชฐเซเชฎเชพเชฃเซเชฏ เชเชฐเซ เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเชตเชพเชจเซ เชชเชฐเชตเชพเชจเชเซ เชเชชเซ เชเซ, เชฌเชเชจเซ เชชเชเชเซเชคเชฟ เชฎเซเชเซเชฏ เช เชจเซ เชเซเชฒเชฎ เชฎเซเชเซเชฏ เชเซเชฐเชฎเชฎเชพเช.
-
ndjson JSON เชชเชฆเชเซเชเซเชฆเชจ เชฎเชพเชเซ. เช เชชเซเชธเซเชคเชเชพเชฒเชฏเชจเซ เชเชชเชฏเซเช เชฎเชพเช เชฅเชพเชฏ เชเซ xtensor เชเซ เชคเซ เชชเซเชฐเซเชเซเชเซเชเชฎเชพเช เชนเชพเชเชฐ เชนเซเชฏ เชคเซ เชเชชเซเชเชช.
-
RcppThread JSON เชคเชฐเชซเชฅเซ เชตเซเชเซเชเชฐเชจเซ เชฎเชฒเซเชเชฟ-เชฅเซเชฐเซเชกเซเชก เชชเซเชฐเซเชธเซเชธเชฟเชเช เชเซเช เชตเชตเชพ เชฎเชพเชเซ. เช เชชเซเชเซเช เชฆเซเชตเชพเชฐเชพ เชชเซเชฐเซ เชชเชพเชกเชตเชพเชฎเชพเช เชเชตเซเชฒ เชนเซเชกเชฐ เชซเชพเชเชฒเซเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ. เชตเชงเซ เชฒเซเชเชชเซเชฐเชฟเชฏ เชฅเซ Rcpp เชธเชฎเชพเชเชคเชฐ เชชเซเชเซเช, เช เชจเซเชฏ เชตเชธเซเชคเซเชเชจเซ เชธเชพเชฅเซ, เชฌเชฟเชฒเซเช-เชเชจ เชฒเซเชช เชเชจเซเชเชฐเชชเซเช เชฎเชฟเชเซเชจเชฟเชเชฎ เชงเชฐเชพเชตเซ เชเซ.
เชคเซ เชจเซเชเชงเชตเซเช เชตเชฐเซเชฅ เชเซ เชเซ xtensor เชเช เชเซเชกเชธเซเชจเซเชก เชนเซเชตเชพเชจเซเช เชฌเชนเชพเชฐ เชเชตเซเชฏเซเช: เชนเชเซเชเชค เช เชเซ เชเซ เชคเซเชจเซ เชชเชพเชธเซ เชตเซเชฏเชพเชชเช เชเชพเชฐเซเชฏเชเซเชทเชฎเชคเชพ เช เชจเซ เชเชเซเช เชชเซเชฐเชฆเชฐเซเชถเชจ เชเซ, เชคเซเชจเชพ เชตเชฟเชเชพเชธเชเชฐเซเชคเชพเช เชคเชฆเซเชฆเชจ เชชเซเชฐเชคเชฟเชญเชพเชตเชถเซเชฒ เชนเซเชตเชพเชจเซเช เชฌเชนเชพเชฐ เชเชตเซเชฏเซเช เชเซ เช เชจเซ เชชเซเชฐเชถเซเชจเซเชจเชพ เชคเชฐเชค เช เชจเซ เชตเชฟเชเชคเชตเชพเชฐ เชเชตเชพเชฌเซ เชเชชเซเชฏเชพ เชเซ. เชคเซเชฎเชจเซ เชฎเชฆเชฆเชฅเซ, เชเชชเชจเชธเซเชตเซ เชฎเซเชเซเชฐเชฟเชธเซเชธเชจเชพ เชเชเซเชธเชเซเชจเซเชธเชฐ เชเซเชจเซเชธเชฐเชฎเชพเช เชฐเซเชชเชพเชเชคเชฐเชฃเชจเซ เช เชฎเชฒเชฎเชพเช เชฎเซเชเชตเซเช เชถเชเซเชฏ เชนเชคเซเช, เชคเซเชฎเช 3-เชชเชฐเชฟเชฎเชพเชฃเซเชฏ เชเชฎเซเช เชเซเชจเซเชธเชฐเชจเซ เชฏเซเชเซเชฏ เชชเชฐเชฟเชฎเชพเชฃ (เชฌเซเช เชชเซเชคเซ) เชจเชพ 4-เชชเชฐเชฟเชฎเชพเชฃเซเชฏ เชเซเชจเซเชธเชฐเชฎเชพเช เชเซเชกเชตเชพเชจเซ เชฐเซเชค.
Rcpp, xtensor เช เชจเซ RcppThread เชถเซเชเชตเชพ เชฎเชพเชเซเชจเซ เชธเชพเชฎเชเซเชฐเซ
เชธเชฟเชธเซเชเชฎ เชซเชพเชเชฒเซ เช เชจเซ เชธเชฟเชธเซเชเชฎ เชชเชฐ เชเชจเซเชธเซเชเซเชฒ เชเชฐเซเชฒเซ เชฒเชพเชเชฌเซเชฐเซเชฐเซเช เชธเชพเชฅเซ เชกเชพเชฏเชจเซเชฎเชฟเช เชฒเชฟเชเชเชฟเชเชเชจเซ เชเชชเชฏเซเช เชเชฐเชคเซ เชซเชพเชเชฒเซเชจเซ เชเชฎเซเชชเชพเชเชฒ เชเชฐเชตเชพ เชฎเชพเชเซ, เช เชฎเซ เชชเซเชเซเชเชฎเชพเช เช เชฎเชฒเชฎเชพเช เชฎเซเชเชพเชฏเซเชฒ เชชเซเชฒเชเชเชจ เชฎเชฟเชเซเชจเชฟเชเชฎเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ. เชเชฐเชธเซเชชเซเชชเซ. เชเชชเชฎเซเชณเซ เชชเชพเชฅ เช เชจเซ เชซเซเชฒเซเชเซเชธ เชถเซเชงเชตเชพ เชฎเชพเชเซ, เช เชฎเซ เชเช เชฒเซเชเชชเซเชฐเชฟเชฏ Linux เชเชชเชฏเซเชเชฟเชคเชพเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ เชเซ pkg-config.
OpenCV เชฒเชพเชเชฌเซเชฐเซเชฐเซเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพ เชฎเชพเชเซ Rcpp เชชเซเชฒเชเชเชจเชจเซเช เช เชฎเชฒเซเชเชฐเชฃ
Rcpp::registerPlugin("opencv", function() {
# ะะพะทะผะพะถะฝัะต ะฝะฐะทะฒะฐะฝะธั ะฟะฐะบะตัะฐ
pkg_config_name <- c("opencv", "opencv4")
# ะะธะฝะฐัะฝัะน ัะฐะนะป ััะธะปะธัั pkg-config
pkg_config_bin <- Sys.which("pkg-config")
# ะัะพะฒัะตะบะฐ ะฝะฐะปะธัะธั ััะธะปะธัั ะฒ ัะธััะตะผะต
checkmate::assert_file_exists(pkg_config_bin, access = "x")
# ะัะพะฒะตัะบะฐ ะฝะฐะปะธัะธั ัะฐะนะปะฐ ะฝะฐัััะพะตะบ OpenCV ะดะปั pkg-config
check <- sapply(pkg_config_name,
function(pkg) system(paste(pkg_config_bin, pkg)))
if (all(check != 0)) {
stop("OpenCV config for the pkg-config not found", call. = FALSE)
}
pkg_config_name <- pkg_config_name[check == 0]
list(env = list(
PKG_CXXFLAGS = system(paste(pkg_config_bin, "--cflags", pkg_config_name),
intern = TRUE),
PKG_LIBS = system(paste(pkg_config_bin, "--libs", pkg_config_name),
intern = TRUE)
))
})
เชชเซเชฒเชเชเชจเชจเซ เชเชพเชฎเชเซเชฐเซเชจเชพ เชชเชฐเชฟเชฃเชพเชฎเซ, เชจเซเชเซเชจเชพ เชฎเซเชฒเซเชฏเซ เชธเชเชเชฒเชจ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชฆเชฐเชฎเชฟเชฏเชพเชจ เชฌเชฆเชฒเชตเชพเชฎเชพเช เชเชตเชถเซ:
Rcpp:::.plugins$opencv()$env
# $PKG_CXXFLAGS
# [1] "-I/usr/include/opencv"
#
# $PKG_LIBS
# [1] "-lopencv_shape -lopencv_stitching -lopencv_superres -lopencv_videostab -lopencv_aruco -lopencv_bgsegm -lopencv_bioinspired -lopencv_ccalib -lopencv_datasets -lopencv_dpm -lopencv_face -lopencv_freetype -lopencv_fuzzy -lopencv_hdf -lopencv_line_descriptor -lopencv_optflow -lopencv_video -lopencv_plot -lopencv_reg -lopencv_saliency -lopencv_stereo -lopencv_structured_light -lopencv_phase_unwrapping -lopencv_rgbd -lopencv_viz -lopencv_surface_matching -lopencv_text -lopencv_ximgproc -lopencv_calib3d -lopencv_features2d -lopencv_flann -lopencv_xobjdetect -lopencv_objdetect -lopencv_ml -lopencv_xphoto -lopencv_highgui -lopencv_videoio -lopencv_imgcodecs -lopencv_photo -lopencv_imgproc -lopencv_core"
JSON เชจเซ เชชเชพเชฐเซเชธ เชเชฐเชตเชพ เช เชจเซ เชฎเซเชกเซเชฒเชฎเชพเช เชเซเชฐเชพเชจเซเชธเชฎเชฟเชถเชจ เชฎเชพเชเซ เชฌเซเช เชเชจเชฐเซเช เชเชฐเชตเชพ เชฎเชพเชเซเชจเซ เช เชฎเชฒเซเชเชฐเชฃ เชเซเชก เชธเซเชชเซเชเชฒเชฐ เชนเซเช เชณ เชเชชเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชเซ. เชชเซเชฐเชฅเชฎ, เชนเซเชกเชฐ เชซเชพเชเชฒเซ เชถเซเชงเชตเชพ เชฎเชพเชเซ เชธเซเชฅเชพเชจเชฟเช เชชเซเชฐเซเชเซเชเซเช เชกเชฟเชฐเซเชเซเชเชฐเซ เชเชฎเซเชฐเซ (ndjson เชฎเชพเชเซ เชเชฐเซเชฐเซ):
Sys.setenv("PKG_CXXFLAGS" = paste0("-I", normalizePath(file.path("src"))))
C++ เชฎเชพเช เชเซเชจเซเชธเชฐ เชฐเซเชชเชพเชเชคเชฐเชฃ เชฎเชพเชเซ JSON เชจเซ เช เชฎเชฒ
// [[Rcpp::plugins(cpp14)]]
// [[Rcpp::plugins(opencv)]]
// [[Rcpp::depends(xtensor)]]
// [[Rcpp::depends(RcppThread)]]
#include <xtensor/xjson.hpp>
#include <xtensor/xadapt.hpp>
#include <xtensor/xview.hpp>
#include <xtensor-r/rtensor.hpp>
#include <opencv2/core/core.hpp>
#include <opencv2/highgui/highgui.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <Rcpp.h>
#include <RcppThread.h>
// ะกะธะฝะพะฝะธะผั ะดะปั ัะธะฟะพะฒ
using RcppThread::parallelFor;
using json = nlohmann::json;
using points = xt::xtensor<double,2>; // ะะทะฒะปะตััะฝะฝัะต ะธะท JSON ะบะพะพัะดะธะฝะฐัั ัะพัะตะบ
using strokes = std::vector<points>; // ะะทะฒะปะตััะฝะฝัะต ะธะท JSON ะบะพะพัะดะธะฝะฐัั ัะพัะตะบ
using xtensor3d = xt::xtensor<double, 3>; // ะขะตะฝะทะพั ะดะปั ั
ัะฐะฝะตะฝะธั ะผะฐััะธัั ะธะทะพะพะฑัะฐะถะตะฝะธั
using xtensor4d = xt::xtensor<double, 4>; // ะขะตะฝะทะพั ะดะปั ั
ัะฐะฝะตะฝะธั ะผะฝะพะถะตััะฒะฐ ะธะทะพะฑัะฐะถะตะฝะธะน
using rtensor3d = xt::rtensor<double, 3>; // ะะฑัััะบะฐ ะดะปั ัะบัะฟะพััะฐ ะฒ R
using rtensor4d = xt::rtensor<double, 4>; // ะะฑัััะบะฐ ะดะปั ัะบัะฟะพััะฐ ะฒ R
// ะกัะฐัะธัะตัะบะธะต ะบะพะฝััะฐะฝัั
// ะ ะฐะทะผะตั ะธะทะพะฑัะฐะถะตะฝะธั ะฒ ะฟะธะบัะตะปัั
const static int SIZE = 256;
// ะขะธะฟ ะปะธะฝะธะธ
// ะกะผ. https://en.wikipedia.org/wiki/Pixel_connectivity#2-dimensional
const static int LINE_TYPE = cv::LINE_4;
// ะขะพะปัะธะฝะฐ ะปะธะฝะธะธ ะฒ ะฟะธะบัะตะปัั
const static int LINE_WIDTH = 3;
// ะะปะณะพัะธัะผ ัะตัะฐะนะทะฐ
// https://docs.opencv.org/3.1.0/da/d54/group__imgproc__transform.html#ga5bb5a1fea74ea38e1a5445ca803ff121
const static int RESIZE_TYPE = cv::INTER_LINEAR;
// ะจะฐะฑะปะพะฝ ะดะปั ะบะพะฝะฒะตััะธัะพะฒะฐะฝะธั OpenCV-ะผะฐััะธัั ะฒ ัะตะฝะทะพั
template <typename T, int NCH, typename XT=xt::xtensor<T,3,xt::layout_type::column_major>>
XT to_xt(const cv::Mat_<cv::Vec<T, NCH>>& src) {
// ะ ะฐะทะผะตัะฝะพััั ัะตะปะตะฒะพะณะพ ัะตะฝะทะพัะฐ
std::vector<int> shape = {src.rows, src.cols, NCH};
// ะะฑัะตะต ะบะพะปะธัะตััะฒะพ ัะปะตะผะตะฝัะพะฒ ะฒ ะผะฐััะธะฒะต
size_t size = src.total() * NCH;
// ะัะตะพะฑัะฐะทะพะฒะฐะฝะธะต cv::Mat ะฒ xt::xtensor
XT res = xt::adapt((T*) src.data, size, xt::no_ownership(), shape);
return res;
}
// ะัะตะพะฑัะฐะทะพะฒะฐะฝะธะต JSON ะฒ ัะฟะธัะพะบ ะบะพะพัะดะธะฝะฐั ัะพัะตะบ
strokes parse_json(const std::string& x) {
auto j = json::parse(x);
// ะ ะตะทัะปััะฐั ะฟะฐััะธะฝะณะฐ ะดะพะปะถะตะฝ ะฑััั ะผะฐััะธะฒะพะผ
if (!j.is_array()) {
throw std::runtime_error("'x' must be JSON array.");
}
strokes res;
res.reserve(j.size());
for (const auto& a: j) {
// ะะฐะถะดัะน ัะปะตะผะตะฝั ะผะฐััะธะฒะฐ ะดะพะปะถะตะฝ ะฑััั 2-ะผะตัะฝัะผ ะผะฐััะธะฒะพะผ
if (!a.is_array() || a.size() != 2) {
throw std::runtime_error("'x' must include only 2d arrays.");
}
// ะะทะฒะปะตัะตะฝะธะต ะฒะตะบัะพัะฐ ัะพัะตะบ
auto p = a.get<points>();
res.push_back(p);
}
return res;
}
// ะััะธัะพะฒะบะฐ ะปะธะฝะธะน
// ะฆะฒะตัะฐ HSV
cv::Mat ocv_draw_lines(const strokes& x, bool color = true) {
// ะัั
ะพะดะฝัะน ัะธะฟ ะผะฐััะธัั
auto stype = color ? CV_8UC3 : CV_8UC1;
// ะัะพะณะพะฒัะน ัะธะฟ ะผะฐััะธัั
auto dtype = color ? CV_32FC3 : CV_32FC1;
auto bg = color ? cv::Scalar(0, 0, 255) : cv::Scalar(255);
auto col = color ? cv::Scalar(0, 255, 220) : cv::Scalar(0);
cv::Mat img = cv::Mat(SIZE, SIZE, stype, bg);
// ะะพะปะธัะตััะฒะพ ะปะธะฝะธะน
size_t n = x.size();
for (const auto& s: x) {
// ะะพะปะธัะตััะฒะพ ัะพัะตะบ ะฒ ะปะธะฝะธะธ
size_t n_points = s.shape()[1];
for (size_t i = 0; i < n_points - 1; ++i) {
// ะขะพัะบะฐ ะฝะฐัะฐะปะฐ ัััะธั
ะฐ
cv::Point from(s(0, i), s(1, i));
// ะขะพัะบะฐ ะพะบะพะฝัะฐะฝะธั ัััะธั
ะฐ
cv::Point to(s(0, i + 1), s(1, i + 1));
// ะััะธัะพะฒะบะฐ ะปะธะฝะธะธ
cv::line(img, from, to, col, LINE_WIDTH, LINE_TYPE);
}
if (color) {
// ะะตะฝัะตะผ ัะฒะตั ะปะธะฝะธะธ
col[0] += 180 / n;
}
}
if (color) {
// ะะตะฝัะตะผ ัะฒะตัะพะฒะพะต ะฟัะตะดััะฐะฒะปะตะฝะธะต ะฝะฐ RGB
cv::cvtColor(img, img, cv::COLOR_HSV2RGB);
}
// ะะตะฝัะตะผ ัะพัะผะฐั ะฟัะตะดััะฐะฒะปะตะฝะธั ะฝะฐ float32 ั ะดะธะฐะฟะฐะทะพะฝะพะผ [0, 1]
img.convertTo(img, dtype, 1 / 255.0);
return img;
}
// ะะฑัะฐะฑะพัะบะฐ JSON ะธ ะฟะพะปััะตะฝะธะต ัะตะฝะทะพัะฐ ั ะดะฐะฝะฝัะผะธ ะธะทะพะฑัะฐะถะตะฝะธั
xtensor3d process(const std::string& x, double scale = 1.0, bool color = true) {
auto p = parse_json(x);
auto img = ocv_draw_lines(p, color);
if (scale != 1) {
cv::Mat out;
cv::resize(img, out, cv::Size(), scale, scale, RESIZE_TYPE);
cv::swap(img, out);
out.release();
}
xtensor3d arr = color ? to_xt<double,3>(img) : to_xt<double,1>(img);
return arr;
}
// [[Rcpp::export]]
rtensor3d cpp_process_json_str(const std::string& x,
double scale = 1.0,
bool color = true) {
xtensor3d res = process(x, scale, color);
return res;
}
// [[Rcpp::export]]
rtensor4d cpp_process_json_vector(const std::vector<std::string>& x,
double scale = 1.0,
bool color = false) {
size_t n = x.size();
size_t dim = floor(SIZE * scale);
size_t channels = color ? 3 : 1;
xtensor4d res({n, dim, dim, channels});
parallelFor(0, n, [&x, &res, scale, color](int i) {
xtensor3d tmp = process(x[i], scale, color);
auto view = xt::view(res, i, xt::all(), xt::all(), xt::all());
view = tmp;
});
return res;
}
เช เชเซเชก เชซเชพเชเชฒเชฎเชพเช เชฎเซเชเชตเซ เชเซเชเช src/cv_xt.cpp
เช
เชจเซ เชเชฆเซเชถ เชธเชพเชฅเซ เชเชฎเซเชชเชพเชเชฒ เชเชฐเซ Rcpp::sourceCpp(file = "src/cv_xt.cpp", env = .GlobalEnv)
; เชเชพเชฎ เชฎเชพเชเซ เชชเชฃ เชเชฐเซเชฐเซ เชเซ nlohmann/json.hpp
เชฅเซ
-
to_xt
- เชเชฎเซเช เชฎเซเชเซเชฐเชฟเชเซเชธเชจเซ เชฐเซเชชเชพเชเชคเชฐเชฟเชค เชเชฐเชตเชพ เชฎเชพเชเซ เชเช เชเซเชฎเซเชชเชฒเซเชเซเชก เชเชพเชฐเซเชฏ (cv::Mat
) เชเช เชเซเชจเซเชธเชฐ เชฎเชพเชเซxt::xtensor
; -
parse_json
โ เชซเชเชเซเชถเชจ JSON เชธเซเชเซเชฐเชฟเชเชเชจเซ เชชเชพเชฐเซเชธ เชเชฐเซ เชเซ, เชชเซเชเชจเซเชเชจเชพ เชเซเชเชฐเซเชกเชฟเชจเซเชเซเชธเชจเซ เชฌเชนเชพเชฐ เชเชพเชขเซ เชเซ, เชคเซเชฎเชจเซ เชตเซเชเซเชเชฐเชฎเชพเช เชชเซเช เชเชฐเซ เชเซ; -
ocv_draw_lines
- เชฌเชฟเชเชฆเซเชเชจเชพ เชชเชฐเชฟเชฃเชพเชฎเซ เชตเซเชเซเชเชฐเชฎเชพเชเชฅเซ, เชฌเชนเซ เชฐเชเชเซเชจ เชฐเซเชเชพเช เชฆเซเชฐเซ เชเซ; -
process
โ เชเชชเชฐเซเชเซเชค เชเชพเชฐเซเชฏเซเชจเซ เชเซเชกเซ เชเซ เช เชจเซ เชชเชฐเชฟเชฃเชพเชฎเซ เชเชฌเซเชจเซ เชฎเชพเชชเชตเชพเชจเซ เชเซเชทเชฎเชคเชพ เชชเชฃ เชเชฎเซเชฐเซ เชเซ; -
cpp_process_json_str
- เชเชพเชฐเซเชฏ เชชเชฐ เชเชตเชฐเชฃprocess
, เชเซ เชชเชฐเชฟเชฃเชพเชฎเชจเซ เชเชฐ-เชเชฌเซเชเซเชเซเช (เชฌเชนเซเชชเชฐเชฟเชฎเชพเชฃเซเชฏ เชเชฐเซ) เชชเชฐ เชจเชฟเชเชพเชธ เชเชฐเซ เชเซ; -
cpp_process_json_vector
- เชเชพเชฐเซเชฏ เชชเชฐ เชเชตเชฐเชฃcpp_process_json_str
, เชเซ เชคเชฎเชจเซ เชฎเชฒเซเชเซ-เชฅเซเชฐเซเชกเซเชก เชฎเซเชกเชฎเชพเช เชธเซเชเซเชฐเชฟเชเช เชตเซเชเซเชเชฐ เชชเชฐ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชเชฐเชตเชพเชจเซ เชฎเชเชเซเชฐเซ เชเชชเซ เชเซ.
เชฌเชนเซ เชฐเชเชเซเชจ เชฐเซเชเชพเช เชฆเซเชฐเชตเชพ เชฎเชพเชเซ, HSV เชฐเชเช เชฎเซเชกเซเชฒเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชนเชคเซ, เชคเซเชฏเชพเชฐเชฌเชพเชฆ RGB เชฎเชพเช เชฐเซเชชเชพเชเชคเชฐ เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช. เชเชพเชฒเซ เชชเชฐเชฟเชฃเชพเชฎเชจเซเช เชชเชฐเซเชเซเชทเชฃ เชเชฐเซเช:
arr <- cpp_process_json_str(tmp_data[4, drawing])
dim(arr)
# [1] 256 256 3
plot(magick::image_read(arr))
R เช
เชจเซ C++ เชฎเชพเช เช
เชฎเชฒเซเชเชฐเชฃเชจเซ เชเชกเชชเชจเซ เชธเชฐเชเชพเชฎเชฃเซ
res_bench <- bench::mark(
r_process_json_str(tmp_data[4, drawing], scale = 0.5),
cpp_process_json_str(tmp_data[4, drawing], scale = 0.5),
check = FALSE,
min_iterations = 100
)
# ะะฐัะฐะผะตััั ะฑะตะฝัะผะฐัะบะฐ
cols <- c("expression", "min", "median", "max", "itr/sec", "total_time", "n_itr")
res_bench[, cols]
# expression min median max `itr/sec` total_time n_itr
# <chr> <bch:tm> <bch:tm> <bch:tm> <dbl> <bch:tm> <int>
# 1 r_process_json_str 3.49ms 3.55ms 4.47ms 273. 490ms 134
# 2 cpp_process_json_str 1.94ms 2.02ms 5.32ms 489. 497ms 243
library(ggplot2)
# ะัะพะฒะตะดะตะฝะธะต ะทะฐะผะตัะฐ
res_bench <- bench::press(
batch_size = 2^(4:10),
{
.data <- tmp_data[sample(seq_len(.N), batch_size), drawing]
bench::mark(
r_process_json_vector(.data, scale = 0.5),
cpp_process_json_vector(.data, scale = 0.5),
min_iterations = 50,
check = FALSE
)
}
)
res_bench[, cols]
# expression batch_size min median max `itr/sec` total_time n_itr
# <chr> <dbl> <bch:tm> <bch:tm> <bch:tm> <dbl> <bch:tm> <int>
# 1 r 16 50.61ms 53.34ms 54.82ms 19.1 471.13ms 9
# 2 cpp 16 4.46ms 5.39ms 7.78ms 192. 474.09ms 91
# 3 r 32 105.7ms 109.74ms 212.26ms 7.69 6.5s 50
# 4 cpp 32 7.76ms 10.97ms 15.23ms 95.6 522.78ms 50
# 5 r 64 211.41ms 226.18ms 332.65ms 3.85 12.99s 50
# 6 cpp 64 25.09ms 27.34ms 32.04ms 36.0 1.39s 50
# 7 r 128 534.5ms 627.92ms 659.08ms 1.61 31.03s 50
# 8 cpp 128 56.37ms 58.46ms 66.03ms 16.9 2.95s 50
# 9 r 256 1.15s 1.18s 1.29s 0.851 58.78s 50
# 10 cpp 256 114.97ms 117.39ms 130.09ms 8.45 5.92s 50
# 11 r 512 2.09s 2.15s 2.32s 0.463 1.8m 50
# 12 cpp 512 230.81ms 235.6ms 261.99ms 4.18 11.97s 50
# 13 r 1024 4s 4.22s 4.4s 0.238 3.5m 50
# 14 cpp 1024 410.48ms 431.43ms 462.44ms 2.33 21.45s 50
ggplot(res_bench, aes(x = factor(batch_size), y = median,
group = expression, color = expression)) +
geom_point() +
geom_line() +
ylab("median time, s") +
theme_minimal() +
scale_color_discrete(name = "", labels = c("cpp", "r")) +
theme(legend.position = "bottom")
เชเซเชฎ เชคเชฎเซ เชเซเช เชถเชเซ เชเซ, เชเชกเชช เชตเชงเชพเชฐเซ เชเซเชฌ เช เชจเซเชเชงเชชเชพเชคเซเชฐ เชนเซเชตเชพเชจเซเช เชฌเชนเชพเชฐ เชเชตเซเชฏเซเช เชเซ, เช เชจเซ R เชเซเชกเชจเซ เชธเชฎเชพเชเชคเชฐ เชเชฐเซเชจเซ C++ เชเซเชก เชธเชพเชฅเซ เชชเชเชกเชตเซเช เชถเชเซเชฏ เชจเชฅเซ.
3. เชกเซเชเชพเชฌเซเชเชฎเชพเชเชฅเซ เชฌเซเชเชจเซ เช เชจเชฒเซเชก เชเชฐเชตเชพ เชฎเชพเชเซ เชเชเชฐเซเชเชฐเซเชธ
R เช RAM เชฎเชพเช เชฌเชเชงเชฌเซเชธเชคเชพ เชกเซเชเชพเชจเซ เชชเซเชฐเชเซเชฐเชฟเชฏเชพ เชเชฐเชตเชพ เชฎเชพเชเซ เชธเชพเชฐเซ เชฐเซเชคเซ เชฒเชพเชฏเช เชชเซเชฐเชคเชฟเชทเซเช เชพ เชงเชฐเชพเชตเซ เชเซ, เชเซเชฏเชพเชฐเซ Python เช เชชเซเชจเชฐเชพเชตเชฐเซเชคเชฟเชค เชกเซเชเชพ เชชเซเชฐเซเชธเซเชธเชฟเชเช เชฆเซเชตเชพเชฐเชพ เชตเชงเซ เชฒเชพเชเซเชทเชฃเชฟเชเชคเชพ เชงเชฐเชพเชตเซ เชเซ, เชเซ เชคเชฎเชจเซ เชเชเช-เชเชซ-เชเซเชฐ เชเชฃเชคเชฐเซเช (เชฌเชพเชนเซเชฏ เชฎเซเชฎเชฐเซเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเชฃเชคเชฐเซเช) เชธเชฐเชณเชคเชพเชฅเซ เช เชจเซ เชเซเชฆเชฐเชคเซ เชฐเซเชคเซ เช เชฎเชฒเชฎเชพเช เชฎเซเชเชตเชพเชจเซ เชฎเชเชเซเชฐเซ เชเชชเซ เชเซ. เชตเชฐเซเชฃเชตเซเชฒ เชธเชฎเชธเซเชฏเชพเชจเชพ เชธเชเชฆเชฐเซเชญเชฎเชพเช เช เชฎเชพเชฐเชพ เชฎเชพเชเซ เชเซเชฒเชพเชธเชฟเช เช เชจเซ เชธเซเชธเชเชเชค เชเชฆเชพเชนเชฐเชฃ เช เชกเซเชช เชจเซเชฏเซเชฐเชฒ เชจเซเชเชตเชฐเซเชเซเชธ เชเซ เชเซ เชเซเชฐเซเชกเชฟเชฏเชจเซเช เชกเชฟเชธเซเชจเซเช เชชเชฆเซเชงเชคเชฟ เชฆเซเชตเชพเชฐเชพ เชชเซเชฐเชถเชฟเชเซเชทเชฟเชค เชเซ เช เชจเซ เชฆเชฐเซเช เชชเชเชฒเชพ เชชเชฐ เช เชตเชฒเซเชเชจเซเชจเชพ เชจเชพเชจเชพ เชญเชพเช เช เชฅเชตเชพ เชฎเซเชจเซ-เชฌเซเชเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชเซเชฐเซเชกเชฟเชฏเชจเซเชเชจเชพ เช เชเชฆเชพเช เชธเชพเชฅเซ.
เชชเชพเชฏเชฅเซเชจเชฎเชพเช เชฒเชเซเชฒเชพ เชกเซเชช เชฒเชฐเซเชจเชฟเชเช เชซเซเชฐเซเชฎเชตเชฐเซเชเชฎเชพเช เชตเชฟเชถเชฟเชทเซเช เชตเชฐเซเชเซ เชนเซเชฏ เชเซ เชเซ เชกเซเชเชพเชจเชพ เชเชงเชพเชฐเซ เชชเซเชจเชฐเชพเชตเชฐเซเชคเชเซเชจเซ เช เชฎเชฒเชฎเชพเช เชฎเซเชเซ เชเซ: เชเซเชทเซเชเชเซ, เชซเซเชฒเซเชกเชฐเซเชธเชฎเชพเช เชเชฟเชคเซเชฐเซ, เชฌเชพเชเชจเชฐเซ เชซเซเชฐเซเชฎเซเชเซเชธ เชตเชเซเชฐเซ. เชคเชฎเซ เชเซเชเซเชเชธ เชเชพเชฐเซเชฏเซ เชฎเชพเชเซ เชคเซเชฏเชพเชฐ เชตเชฟเชเชฒเซเชชเซเชจเซ เชเชชเชฏเซเช เชเชฐเซ เชถเชเซ เชเซ เช เชฅเชตเชพ เชคเชฎเชพเชฐเชพ เชชเซเชคเชพเชจเชพ เชฒเชเซ เชถเชเซ เชเซ. R เชฎเชพเช เชเชชเชฃเซ Python เชฒเชพเชเชฌเซเชฐเซเชฐเซเชจเซ เชคเชฎเชพเชฎ เชธเซเชตเชฟเชงเชพเชเชจเซ เชฒเชพเชญ เชฒเช เชถเชเซเช เชเซเช เชเซเชฐเชพ เชธเชฎเชพเชจ เชจเชพเชฎเชจเชพ เชชเซเชเซเชเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชคเซเชจเชพ เชตเชฟเชตเชฟเชง เชฌเซเชเชเชจเซเชก เชธเชพเชฅเซ, เชเซ เชฌเชฆเชฒเชพเชฎเชพเช เชชเซเชเซเชเชจเซ เชเซเช เชชเชฐ เชเชพเชฎ เชเชฐเซ เชเซ เชเชพเชณเซเชฆเชพเชฐ. เชฌเชพเชฆเชฎเชพเช เชเช เช เชฒเช เชฒเชพเชเชฌเชพ เชฒเซเชเชจเซ เชชเชพเชคเซเชฐ เชเซ; เชคเซ เชฎเชพเชคเซเชฐ เชคเชฎเชจเซ R เชฅเซ Python เชเซเชก เชเชฒเชพเชตเชตเชพเชจเซ เชฎเชเชเซเชฐเซ เชเชชเชคเซเช เชจเชฅเซ, เชชเชฃ เชคเชฎเชจเซ R เช เชจเซ Python เชธเชคเซเชฐเซ เชตเชเซเชเซ เชเชฌเซเชเซเชเซเชเซเชธ เชธเซเชฅเชพเชจเชพเชเชคเชฐเชฟเชค เชเชฐเชตเชพเชจเซ เชชเชฃ เชชเชฐเชตเชพเชจเชเซ เชเชชเซ เชเซ, เชเชชเชฎเซเชณเซ เชคเชฎเชพเชฎ เชเชฐเซเชฐเซ เชชเซเชฐเชเชพเชฐเชจเชพ เชฐเซเชชเชพเชเชคเชฐเชฃเซ เชเชฐเซ เชเซ.
เช เชฎเซ MonetDBLite เชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชคเชฎเชพเชฎ เชกเซเชเชพเชจเซ RAM เชฎเชพเช เชธเชเชเซเชฐเชนเชฟเชค เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐเชฟเชฏเชพเชคเชฎเชพเชเชฅเซ เชเซเชเชเชพเชฐเซ เชฎเซเชณเชตเซเชฏเซ, เชฌเชงเชพ "เชจเซเชฏเซเชฐเชฒ เชจเซเชเชตเชฐเซเช" เชเชพเชฐเซเชฏ เชชเชพเชฏเชฅเซเชจเชฎเชพเช เชฎเซเชณ เชเซเชก เชฆเซเชตเชพเชฐเชพ เชเชฐเชตเชพเชฎเชพเช เชเชตเชถเซ, เช เชฎเชพเชฐเซ เชซเชเซเชค เชกเซเชเชพ เชชเชฐ เชเช เชชเซเชจเชฐเชพเชตเชฐเซเชคเชจ เชฒเชเชตเชพเชจเซเช เชเซ, เชเชพเชฐเชฃ เชเซ เชคเซเชฏเชพเช เชเชเช เชคเซเชฏเชพเชฐ เชจเชฅเซ. R เช เชฅเชตเชพ Python เชฎเชพเช เชเชตเซ เชชเชฐเชฟเชธเซเชฅเชฟเชคเชฟ เชฎเชพเชเซ. เชคเซเชจเชพ เชฎเชพเชเซ เช เชจเชฟเชตเชพเชฐเซเชฏเชชเชฃเซ เชฎเชพเชคเซเชฐ เชฌเซ เชเชตเชถเซเชฏเชเชคเชพเช เชเซ: เชคเซเชฃเซ เช เชจเชเชค เชฒเซเชชเชฎเชพเช เชฌเซเช เชชเชฐเชค เชเชฐเชตเชพ เชเซเชเช เช เชจเซ เชคเซเชจเซ เชธเซเชฅเชฟเชคเชฟเชจเซ เชชเซเชจเชฐเชพเชตเซเชคเซเชคเชฟเช เชตเชเซเชเซ เชธเชพเชเชตเชตเซ เชเซเชเช (R เชฎเชพเช เชฌเชพเชฆเชฎเชพเช เชฌเชเชงเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชธเชฐเชณ เชฐเซเชคเซ เช เชฎเชฒเชฎเชพเช เชฎเซเชเชตเชพเชฎเชพเช เชเชตเซ เชเซ). เช เชเชพเช, เชเชฐ เชเชฐเซเชจเซ เชชเซเชจเชฐเชพเชตเชฐเซเชคเชเชจเซ เช เชเชฆเชฐ เชจเชฎเซเชชเซ เชเชฐเซเชฎเชพเช เชธเซเชชเชทเซเชเชชเชฃเซ เชฐเซเชชเชพเชเชคเชฐเชฟเชค เชเชฐเชตเซเช เชเชฐเซเชฐเซ เชนเชคเซเช, เชชเชฐเชเชคเซ เชชเซเชเซเชเชจเซเช เชตเชฐเซเชคเชฎเชพเชจ เชธเชเชธเซเชเชฐเชฃ เชเซเชฐเชพ เชคเซ เชชเซเชคเซ เชเชฐเซ เชเซ.
เชคเชพเชฒเซเชฎ เช เชจเซ เชฎเชพเชจเซเชฏเชคเชพ เชกเซเชเชพ เชฎเชพเชเซ เชชเซเชจเชฐเชพเชตเชฐเซเชคเช เชจเซเชเซ เชฎเซเชเชฌ เชฌเชนเชพเชฐ เชเชตเซเชฏเซเช:
เชคเชพเชฒเซเชฎ เช เชจเซ เชฎเชพเชจเซเชฏเชคเชพ เชกเซเชเชพ เชฎเชพเชเซ เชเชเชฐเชฐเซเชเชฐ
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
เช
เชจเซ เชฌเซเช เชจเชเชฌเชฐเซ, เชเชพเชเชจเซเชเชฐ เช
เชจเซ เชฌเซเชเชจเซ เชฎเชนเชคเซเชคเชฎ เชธเชเชเซเชฏเชพ, เชคเซเชฎเช เชกเซเชเชพเชฌเซเชเชฎเชพเชเชฅเซ เชกเซเชเชพ เช
เชจเชฒเซเชก เชเชฐเชตเชพ เชฎเชพเชเซ เชเชธเชเซเชฏเซเชเชฒ เชเชเซเชธเชชเซเชฐเซเชถเชจ. เชตเชงเซเชฎเชพเช, เช
เชฎเซ เช
เชเชฆเชฐเชจเชพ เชเชพเชฐเซเชฏเชจเซเช เชเชกเชชเซ เชเชจเชพเชฒเซเช เชตเซเชฏเชพเชเซเชฏเชพเชฏเชฟเชค เชเชฐเซเชฏเซเช เชเซ 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 เชนเซเชฏ, เชคเซ เชคเชฎเซ เชกเซเชเชพเชฌเซเชเชจเซ เช เช RAM เชชเชฐ เชธเซเชฅเชพเชจเชพเชเชคเชฐเชฟเชค เชเชฐเซเชจเซ เชเชเชญเซเชฐเชคเชพเชฅเซ เชคเซเชจเซ เชเชกเชชเซ เชฌเชจเชพเชตเซ เชถเชเซ เชเซ (32 GB เช
เชฎเชพเชฐเชพ เชเชพเชฐเซเชฏ เชฎเชพเชเซ เชชเซเชฐเชคเซเช เชเซ). 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. เชฎเซเชกเซเชฒ เชเชฐเซเชเชฟเชเซเชเซเชเชฐเชจเซ เชชเชธเชเชฆเชเซ
เชชเซเชฐเชฅเชฎ เชเชฐเซเชเชฟเชเซเชเซเชเชฐเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซ เชนเชคเซ (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
- เชจเชฟเชฏเชฎเชฟเชค เชเชฐ เชฏเชพเชฆเซ), เช
เชจเซ เชเชพเชฐเซเชฏ 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. เชธเซเชเซเชฐเชฟเชชเซเชเซเชธเชจเซเช เชชเซเชฐเชพเชฎเซเชเชฐเชพเชเชเซเชถเชจ
เชธเชเชตเชก เชฎเชพเชเซ, เชคเชพเชฒเซเชฎ เชถเชฐเซ เชเชฐเชตเชพ เชฎเชพเชเซเชจเชพ เชคเชฎเชพเชฎ เชเซเชก เชธเชฟเชเชเชฒ เชธเซเชเซเชฐเชฟเชชเซเช เชคเชฐเซเชเซ เชกเชฟเชเชพเชเชจ เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเชพ เชนเชคเชพ, เชเซเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ เชชเซเชฐเชพเชฎเซเชเชฐเชพเชเชเซเชก เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเชพ เชนเชคเชพ
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)
เชชเซเชเซเช เชฆเชธเซเชคเชพเชตเซเช เช
เชฎเชฒเซเชเชฐเชฃ เชฐเชเซ เชเชฐเซ เชเซ 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
เชตเชฐเซเชคเชฎเชพเชจ เชธเชเชธเซเชเชฐเชฃเชฎเชพเชเชฅเซ เชเซเชฐเชพ เชเชฐ เชเชชเชฏเซเชเชฎเชพเช
เช เช
เชญเชฟเชเชฎเชจเซ เชเชพเชฐเชฃเซ RStudio เชฎเชพเช เชธเซเชเซเชฐเชฟเชชเซเชเชจเชพ เชตเชงเซ เชชเชฐเชเชชเชฐเชพเชเชค เชฒเซเชเชเชจเซ เชคเซเชฒเชจเชพเชฎเชพเช เชตเชฟเชตเชฟเชง เชฎเซเชกเซเชฒเซ เชธเชพเชฅเซเชจเชพ เชชเซเชฐเชฏเซเชเซเชจเซ เชจเซเชเชงเชชเชพเชคเซเชฐ เชฐเซเชคเซ เชเชกเชชเซ เชฌเชจเชพเชตเชตเชพเชจเซเช เชถเชเซเชฏ เชฌเชจเซเชฏเซเช (เช
เชฎเซ เชชเซเชเซเชเชจเซ เชธเชเชญเชตเชฟเชค เชตเชฟเชเชฒเซเชช เชคเชฐเซเชเซ เชจเซเชเชงเซเช เชเซเช.
6. เชธเซเชเซเชฐเชฟเชชเซเชเซเชจเซเช เชกเซเชเชฐเชพเชเชเซเชถเชจ
เช
เชฎเซ เชเซเชฎเชจเชพ เชธเชญเซเชฏเซ เชตเชเซเชเซเชจเชพ เชชเซเชฐเชถเชฟเชเซเชทเชฃ เชฎเซเชกเชฒเซเชธ เชฎเชพเชเซ เช
เชจเซ เชเซเชฒเชพเชเชกเชฎเชพเช เชเชกเชชเซ เชเชฎเชพเชตเช เชฎเชพเชเซ เชชเชฐเซเชฏเชพเชตเชฐเชฃเชจเซ เชชเซเชฐเซเชเซเชฌเชฟเชฒเชฟเชเซ เชธเซเชจเชฟเชถเซเชเชฟเชค เชเชฐเชตเชพ เชฎเชพเชเซ เชกเซเชเชฐเชจเซ เชเชชเชฏเซเช เชเชฐเซเชฏเซ. เชคเชฎเซ เช เชธเชพเชงเชจ เชธเชพเชฅเซ เชชเชฐเชฟเชเชฟเชค เชฅเชตเชพเชจเซเช เชถเชฐเซ เชเชฐเซ เชถเชเซ เชเซ, เชเซ เชเชฐ เชชเซเชฐเซเชเซเชฐเชพเชฎเชฐ เชฎเชพเชเซ เชชเซเชฐเชฎเชพเชฃเชฎเชพเช เช
เชธเชพเชฎเชพเชจเซเชฏ เชเซ, เชธเชพเชฅเซ
เชกเซเชเชฐ เชคเชฎเชจเซ เชถเชฐเซเชเชคเชฅเซ เชคเชฎเชพเชฐเซ เชชเซเชคเชพเชจเซ เชเชฌเซเช เชฌเชจเชพเชตเชตเชพ เช
เชจเซ เชคเชฎเชพเชฐเซ เชชเซเชคเชพเชจเซ เชฌเชจเชพเชตเชตเชพ เชฎเชพเชเซเชจเชพ เชเชงเชพเชฐ เชคเชฐเซเชเซ เช
เชจเซเชฏ เชเชฌเซเชเชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพเชจเซ เชฎเชเชเซเชฐเซ เชเชชเซ เชเซ. เชเชชเชฒเชฌเซเชง เชตเชฟเชเชฒเซเชชเซเชจเซเช เชตเชฟเชถเซเชฒเซเชทเชฃ เชเชฐเชคเซ เชตเชเชคเซ, เช
เชฎเซ เชจเชฟเชทเซเชเชฐเซเชท เชชเชฐ เชเชตเซเชฏเชพ เชเซ 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
. เชเชจเชพเชฅเซ เชเซเชกเชฎเชพเช 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. Google Cloud เชชเชฐ เชฌเชนเซเชตเชฟเชง GPU เชจเซ เชเชชเชฏเซเช เชเชฐเชตเซ
เชธเซเชชเชฐเซเชงเชพเชจเซ เชตเชฟเชถเซเชทเชคเชพเชเชฎเชพเชเชจเซ เชเช เชเซเชฌ เช เชเซเชเชเชพเชเชตเชพเชณเซ เชกเซเชเชพ เชนเชคเซ (เชถเซเชฐเซเชทเชเชจเซเช เชเชฟเชคเซเชฐ เชเซเช, ODS เชธเซเชฒเซเชเชฎเชพเชเชฅเซ @Leigh.plt เชชเชฐเชฅเซ เชเชงเชพเชฐ เชฒเซเชงเซเชฒ). เชฎเซเชเชพ เชฌเซ
เชเซเชธ เชเชจเซ เชธเชพเชฎเชจเซ เชเชฐเชตเชพเชฎเชพเช เชฎเชฆเชฆ เชเชฐเซ เชเซ, เช
เชจเซ 1 GPU เชธเชพเชฅเซ เชชเซเชธเซ เชชเชฐ เชชเซเชฐเชฏเซเชเซ เชชเชเซ, เช
เชฎเซ เชเซเชฒเชพเชเชกเชฎเชพเช เชเชฃเชพ GPUs เชชเชฐ เชคเชพเชฒเซเชฎ เชฎเซเชกเชฒเซเชธเชจเซ เชฎเชพเชธเซเชเชฐ เชเชฐเชตเชพเชจเซเช เชจเชเซเชเซ เชเชฐเซเชฏเซเช. เชตเชชเชฐเชพเชฏเซเชฒ GoogleCloud (dev/shm
.
เชฌเชนเซเชตเชฟเชง GPU เชจเซ เชเชชเชฏเซเช เชเชฐเชตเชพ เชฎเชพเชเซ เชเชตเชพเชฌเชฆเชพเชฐ เชเซเชก เชซเซเชฐเซเชเชฎเซเชจเซเช เชธเซเชฅเซ เชตเชงเซ เชฐเชธเชชเซเชฐเชฆ เชเซ. เชชเซเชฐเชฅเชฎ, เชชเชพเชฏเชฅเซเชจเชจเซ เชเซเชฎ, เชธเชเชฆเชฐเซเชญ เชฎเซเชจเซเชเชฐเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ CPU เชชเชฐ เชฎเซเชกเซเชฒ เชฌเชจเชพเชตเชตเชพเชฎเชพเช เชเชตเซ เชเซ:
with(tensorflow::tf$device("/cpu:0"), {
model_cpu <- get_model(
name = model_name,
input_shape = input_shape,
weights = weights,
metrics =(top_3_categorical_accuracy,
compile = FALSE
)
})
เชชเชเซ เช เชจเชเชฎเซเชชเชพเชเชฒ เชเชฐเซเชฒ (เช เช เชเชคเซเชฏเชจเซเช เชเซ) เชฎเซเชกเซเชฒ เชเชชเซเชฒ เชเชชเชฒเชฌเซเชง GPU เชจเซ เชธเชเชเซเชฏเชพ เชชเชฐ เชเซเชชเชฟ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชเซ, เช เชจเซ เชคเซ เชชเชเซ เช เชคเซ เชธเชเชเชฒเชฟเชค เชฅเชพเชฏ เชเซ:
model <- keras::multi_gpu_model(model_cpu, gpus = n_gpu)
keras::compile(
object = model,
optimizer = keras::optimizer_adam(lr = 0.0004),
loss = "categorical_crossentropy",
metrics = c(top_3_categorical_accuracy)
)
เชเซเชฒเซเชฒเชพ เชเช เชธเชฟเชตเชพเชฏเชจเชพ เชคเชฎเชพเชฎ เชธเซเชคเชฐเซเชจเซ เชซเซเชฐเซเช เชเชฐเชตเชพเชจเซ, เชเซเชฒเซเชฒเชพ เชธเซเชคเชฐเชจเซ เชคเชพเชฒเซเชฎ เชเชชเชตเชพเชจเซ, เชเชฃเชพ GPU เชฎเชพเชเซ เชธเชเชชเซเชฐเซเชฃ เชฎเซเชกเชฒเชจเซ เช เชจเชซเซเชฐเซเช เชเชฐเชตเชพเชจเซ เช เชจเซ เชซเชฐเซเชฅเซ เชคเชพเชฒเซเชฎ เชเชชเชตเชพเชจเซ เชเซเชฒเชพเชธเชฟเช เชคเชเชจเซเช เช เชฎเชฒเชฎเชพเช เชฎเซเชเซ เชถเชเชพเช เชจเชฅเซ.
เชเชชเชฏเซเช เชเชฐเซเชฏเชพ เชตเชฟเชจเชพ เชคเชพเชฒเซเชฎเชจเซเช เชจเชฟเชฐเซเชเซเชทเชฃ เชเชฐเชตเชพเชฎเชพเช เชเชตเซเชฏเซเช เชนเชคเซเช. เชเซเชจเซเชธเชฐเชฌเซเชฐเซเชก, เชฆเชฐเซเช เชฏเซเช เชชเชเซ เชฎเชพเชนเชฟเชคเซเชชเซเชฐเชฆ เชจเชพเชฎเซ เชธเชพเชฅเซ เชฒเซเชเซเชธ เชฐเซเชเซเชฐเซเชก เชเชฐเชตเชพ เช เชจเซ เชฎเซเชกเชฒเชจเซ เชธเชพเชเชตเชตเชพ เชฎเชพเชเซ เชเชพเชคเชจเซ เชฎเชฐเซเชฏเชพเชฆเชฟเชค เชเชฐเซเช เชเซเช:
เชเซเชฒเชฌเซ เชเซเชธ
# ะจะฐะฑะปะพะฝ ะธะผะตะฝะธ ัะฐะนะปะฐ ะปะพะณะฐ
log_file_tmpl <- file.path("logs", sprintf(
"%s_%d_%dch_%s.csv",
model_name,
dim_size,
channels,
format(Sys.time(), "%Y%m%d%H%M%OS")
))
# ะจะฐะฑะปะพะฝ ะธะผะตะฝะธ ัะฐะนะปะฐ ะผะพะดะตะปะธ
model_file_tmpl <- file.path("models", sprintf(
"%s_%d_%dch_{epoch:02d}_{val_loss:.2f}.h5",
model_name,
dim_size,
channels
))
callbacks_list <- list(
keras::callback_csv_logger(
filename = log_file_tmpl
),
keras::callback_early_stopping(
monitor = "val_loss",
min_delta = 1e-4,
patience = 8,
verbose = 1,
mode = "min"
),
keras::callback_reduce_lr_on_plateau(
monitor = "val_loss",
factor = 0.5, # ัะผะตะฝััะฐะตะผ lr ะฒ 2 ัะฐะทะฐ
patience = 4,
verbose = 1,
min_delta = 1e-4,
mode = "min"
),
keras::callback_model_checkpoint(
filepath = model_file_tmpl,
monitor = "val_loss",
save_best_only = FALSE,
save_weights_only = FALSE,
mode = "min"
)
)
8. เชจเชฟเชทเซเชเชฐเซเชทเชจเซ เชฌเชฆเชฒเซ
เช เชธเชเชเซเชฏ เชธเชฎเชธเซเชฏเชพเช เชเซ เชเซเชจเซ เช เชฎเซ เชธเชพเชฎเชจเซ เชเชฐเซเชฏเซ เชเซ เชคเซ เชนเชเซ เชธเซเชงเซ เชฆเซเชฐ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชจเชฅเซ:
- ะฒ เชเซเชฐเชพ เชถเซเชฐเซเชทเซเช เชถเชฟเชเซเชทเชฃ เชฆเชฐ (เชเชจเชพเชฒเซเช
lr_finder
เชชเซเชธเซเชคเชเชพเชฒเชฏเชฎเชพเช เชเชกเชชเซ.เช.เชเช); เชเซเชเชฒเชพเช เชชเซเชฐเชฏเชคเซเชจเซ เชธเชพเชฅเซ, เชคเซเชคเซเชฏ-เชชเชเซเชท เช เชฎเชฒเซเชเชฐเชฃเซเชจเซ R เชชเชฐ เชชเซเชฐเซเช เชเชฐเชตเชพเชจเซเช เชถเชเซเชฏ เชเซ, เชเชฆเชพเชนเชฐเชฃ เชคเชฐเซเชเซ,เช ; - เช เชเชพเชเชจเชพ เชฎเซเชฆเซเชฆเชพเชจเชพ เชชเชฐเชฟเชฃเชพเชฎเซ, เชเชฃเชพ GPU เชจเซ เชเชชเชฏเซเช เชเชฐเชคเซ เชตเชเชคเซ เชฏเซเชเซเชฏ เชคเชพเชฒเซเชฎ เชเชกเชช เชชเชธเชเชฆ เชเชฐเชตเชพเชจเซเช เชถเชเซเชฏ เชจ เชนเชคเซเช;
- เชเชงเซเชจเชฟเช เชจเซเชฏเซเชฐเชฒ เชจเซเชเชตเชฐเซเช เชเชฐเซเชเชฟเชเซเชเซเชเชฐเชจเซ เช เชญเชพเชต เชเซ, เชเชพเชธ เชเชฐเซเชจเซ เชเชฎเซเชเชจเซเช เชชเชฐ เชชเซเชฐเซเชต เชชเซเชฐเชถเชฟเชเซเชทเชฟเชค;
- เชเซเช เชเช เชเชเซเชฐ เชจเซเชคเชฟ เช
เชจเซ เชญเซเชฆเชญเชพเชตเชชเซเชฐเซเชฃ เชถเชฟเชเซเชทเชฃ เชฆเชฐ (เชเซเชธเชพเชเชจ เชเชจเชฟเชฒเชฟเชเช เช
เชฎเชพเชฐเซ เชตเชฟเชจเชเชคเซ เชชเชฐ เชนเชคเซเช
เช เชฎเชฒเชฎเชพเช เชฎเซเชเซเชฏเซ , เชเชญเชพเชฐเชธเซเชเชพเชฏเชกเซเชจ ).
เช เชธเซเชชเชฐเซเชงเชพเชฎเชพเชเชฅเซ เชเช เชเชชเชฏเซเชเซ เชฌเชพเชฌเชคเซ เชถเซเชเชตเชพ เชฎเชณเซ:
- เชชเซเชฐเชฎเชพเชฃเชฎเชพเช เชเชเชพ-เชชเชพเชตเชฐ เชนเชพเชฐเซเชกเชตเซเชฐ เชชเชฐ, เชคเชฎเซ เชชเซเชกเชพ เชตเชฟเชจเชพ เชฏเซเชเซเชฏ (RAM เชจเชพ เชเชฆ เชเชฐเชคเชพเช เชเชฃเซ เชตเชเชค) เชกเซเชเชพเชจเชพ เชตเซเชฒเซเชฏเซเชฎเซ เชธเชพเชฅเซ เชเชพเชฎ เชเชฐเซ เชถเชเซ เชเซ. เชชเซเชฒเชพเชธเซเชเชฟเชเชจเซ เชฅเซเชฒเซ เชกเซเชเชพ.เชเซเชฌเชฒ เชเซเชทเซเชเชเซเชจเชพ เชเชจ-เชชเซเชฒเซเชธ เชซเซเชฐเชซเชพเชฐเชจเซ เชเชพเชฐเชฃเซ เชฎเซเชฎเชฐเซเชจเซ เชฌเชเชพเชตเซ เชเซ, เชเซ เชคเซเชฎเชจเซ เชจเชเชฒ เชเชฐเชตเชพเชจเซเช เชเชพเชณเซ เชเซ, เช เชจเซ เชเซเชฏเชพเชฐเซ เชฏเซเชเซเชฏ เชฐเซเชคเซ เชเชชเชฏเซเชเชฎเชพเช เชฒเซเชตเชพเชฏ เชเซ, เชคเซเชฏเชพเชฐเซ เชคเซเชจเซ เชเซเชทเชฎเชคเชพเช เชฒเชเชญเช เชนเชเชฎเซเชถเชพ เชธเซเชเซเชฐเชฟเชชเซเชเซเชเช เชญเชพเชทเชพเช เชฎเชพเชเซ เช เชฎเชจเซ เชเชพเชฃเซเชคเชพ เชคเชฎเชพเชฎ เชธเชพเชงเชจเซเชฎเชพเช เชธเซเชฅเซ เชตเชงเซ เชเชกเชช เชฆเชฐเซเชถเชพเชตเซ เชเซ. เชกเซเชเชพเชฌเซเชเชฎเชพเช เชกเซเชเชพ เชธเชพเชเชตเชตเชพเชฅเซ เชคเชฎเซ, เชเชฃเชพ เชเชฟเชธเซเชธเชพเชเชฎเชพเช, เชธเชฎเชเซเชฐ เชกเซเชเชพเชธเซเชเชจเซ RAM เชฎเชพเช เชธเซเชเซเชตเชฟเช เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐเชฟเชฏเชพเชค เชตเชฟเชถเซ เชฌเชฟเชฒเชเซเชฒ เชตเชฟเชเชพเชฐเชคเชพ เชจเชฅเซ.
- R เชฎเชพเช เชงเซเชฎเชพ เชเชพเชฐเซเชฏเซเชจเซ เชชเซเชเซเชเชจเซ เชเชชเชฏเซเช เชเชฐเซเชจเซ C++ เชฎเชพเช เชเชกเชชเซ เชเชพเชฐเซเชฏเซ เชธเชพเชฅเซ เชฌเชฆเชฒเซ เชถเชเชพเชฏ เชเซ เชเชฐเชธเซเชชเซเชชเซ. เชเซ เชเชชเชฏเซเช เชเชฐเชตเชพ เชเชชเชฐเชพเชเชค RcppThread เช เชฅเชตเชพ Rcpp เชธเชฎเชพเชเชคเชฐ, เช เชฎเชจเซ เชเซเชฐเซเชธ-เชชเซเชฒเซเชเชซเซเชฐเซเชฎ เชฎเชฒเซเชเซ-เชฅเซเชฐเซเชกเซเชก เช เชฎเชฒเซเชเชฐเชฃ เชฎเชณเซ เชเซ, เชคเซเชฅเซ R เชธเซเชคเชฐ เชชเชฐ เชเซเชกเชจเซ เชธเชฎเชพเชเชคเชฐ เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐ เชจเชฅเซ.
- เชชเซเชเซเช เชเชฐเชธเซเชชเซเชชเซ C++ เชจเชพ เชเชเชญเซเชฐ เชเซเชเชพเชจ เชตเชฟเชจเชพ เชเชชเชฏเซเช เชเชฐเซ เชถเชเชพเชฏ เชเซ, เชเชฐเซเชฐเซ เชจเซเชฏเซเชจเชคเชฎ เชฆเชฐเซเชถเชพเชตเซเชฒ เชเซ
เช เชนเซเช . เชเซเชตเซ เช เชธเชเชเซเชฏ เช เชเชกเซ เชธเซ-เชฒเชพเชเชฌเซเชฐเซเชฐเซเช เชฎเชพเชเซ เชนเซเชกเชฐ เชซเชพเชเชฒเซ xtensor CRAN เชชเชฐ เชเชชเชฒเชฌเซเชง เชเซ, เชเชเชฒเซ เชเซ เชชเซเชฐเซเชเซเชเซเชเชจเชพ เช เชฎเชฒเซเชเชฐเชฃ เชฎเชพเชเซ เชเช เชเชจเซเชซเซเชฐเชพเชธเซเชเซเชฐเชเซเชเชฐเชจเซ เชฐเชเชจเชพ เชเชฐเชตเชพเชฎเชพเช เชเชตเซ เชฐเชนเซ เชเซ เชเซ เชคเซเชฏเชพเชฐ เชเชเซเช-เชชเซเชฐเชฆเชฐเซเชถเชจ C++ เชเซเชกเชจเซ R เชฎเชพเช เชธเชเชเชฒเชฟเชค เชเชฐเซ เชเซ. เชตเชงเชพเชฐเชพเชจเซ เชธเชเชตเชก เชธเชฟเชจเซเชเซเชเซเชธ เชนเชพเชเชฒเชพเชเชเชฟเชเช เช เชจเซ RStudio เชฎเชพเช เชธเซเชฅเชฟเชฐ C++ เชเซเชก เชตเชฟเชถเซเชฒเซเชทเช เชเซ. - เชฆเชธเซเชคเชพเชตเซเช เชคเชฎเชจเซ เชชเชฐเชฟเชฎเชพเชฃเซ เชธเชพเชฅเซ เชธเซเชต-เชธเชฎเชพเชฏเซเชฒ เชธเซเชเซเชฐเชฟเชชเซเชเซ เชเชฒเชพเชตเชตเชพ เชฎเชพเชเซ เชชเชฐเชตเชพเชจเชเซ เชเชชเซ เชเซ. เช เชฐเชฟเชฎเซเช เชธเชฐเซเชตเชฐ เชชเชฐ เชตเชพเชชเชฐเชตเชพ เชฎเชพเชเซ เช เชจเซเชเซเชณ เชเซ, เชธเชนเชฟเชค. เชกเซเชเชฐ เชนเซเช เชณ. เชเชฐเชธเซเชเซเชกเชฟเชฏเซเชฎเชพเช, เชจเซเชฏเซเชฐเชฒ เชจเซเชเชตเชฐเซเชเชจเซ เชคเชพเชฒเซเชฎ เชเชชเชตเชพ เชธเชพเชฅเซ เชเชฃเชพ เชเชฒเชพเชเซ เชชเซเชฐเชฏเซเชเซ เชเชฐเชตเชพ เช เชธเซเชตเชฟเชงเชพเชเชจเช เชเซ, เช เชจเซ เชธเชฐเซเชตเชฐ เชชเชฐ IDE เชเชจเซเชธเซเชเซเชฒ เชเชฐเชตเซเช เชนเชเชฎเซเชถเชพ เชจเซเชฏเชพเชฏเซ เชจเชฅเซ.
- เชกเซเชเชฐ เชเซเชก เชชเซเชฐเซเชเซเชฌเชฟเชฒเชฟเชเซ เช เชจเซ OS เช เชจเซ เชฒเชพเชเชฌเซเชฐเซเชฐเซเชเชจเชพ เชตเชฟเชตเชฟเชง เชธเชเชธเซเชเชฐเชฃเซ เชงเชฐเชพเชตเชคเชพ เชตเชฟเชเชพเชธเชเชฐเซเชคเชพเช เชตเชเซเชเซ เชชเชฐเชฟเชฃเชพเชฎเซเชจเซ เชชเซเชจเชเชเชคเซเชชเชพเชฆเชจเชเซเชทเชฎเชคเชพ เชคเซเชฎเช เชธเชฐเซเชตเชฐ เชชเชฐ เช เชฎเชฒเชฎเชพเช เชธเชฐเชณเชคเชพเชจเซ เชเชพเชคเชฐเซ เชเชฐเซ เชเซ. เชคเชฎเซ เชฎเชพเชคเซเชฐ เชเช เชเชฆเซเชถ เชตเชกเซ เชธเชฎเชเซเชฐ เชคเชพเชฒเซเชฎ เชชเชพเชเชชเชฒเชพเชเชจ เชถเชฐเซ เชเชฐเซ เชถเชเซ เชเซ.
- Google Cloud เช เชเชฐเซเชเชพเชณ เชนเชพเชฐเซเชกเชตเซเชฐ เชชเชฐ เชชเซเชฐเชฏเซเช เชเชฐเชตเชพเชจเซ เชฌเชเซเช-เชซเซเชฐเซเชเชกเชฒเซ เชฐเซเชค เชเซ, เชชเชฐเชเชคเซ เชคเชฎเชพเชฐเซ เชฐเซเชชเชฐเซเชเชพเชเชเชจเซ เชเชพเชณเชเซเชชเซเชฐเซเชตเช เชชเชธเชเชฆ เชเชฐเชตเชพเชจเซ เชเชฐเซเชฐ เชเซ.
- เชตเซเชฏเชเซเชคเชฟเชเชค เชเซเชกเชจเชพ เชเซเชเชกเชพเชเชจเซ เชเชกเชช เชฎเชพเชชเชตเซ เช เชเซเชฌ เช เชเชชเชฏเซเชเซ เชเซ, เชเชพเชธ เชเชฐเซเชจเซ เชเซเชฏเชพเชฐเซ R เช เชจเซ C++เชจเซเช เชธเชเชฏเซเชเชจ เช เชจเซ เชชเซเชเซเช เชธเชพเชฅเซ เชฌเซเชจเซเช - เชชเชฃ เชเซเชฌ เช เชธเชฐเชณ.
เชเชเชเชฆเชฐเซ เช เช เชจเซเชญเชต เชเซเชฌ เช เชฒเชพเชญเชฆเชพเชฏเซ เชนเชคเซ เช เชจเซ เช เชฎเซ เชเชญเชพ เชฅเชฏเซเชฒเชพ เชเซเชเชฒเชพเช เชฎเซเชฆเซเชฆเชพเชเชจเซ เชเชเซเชฒเชตเชพ เชฎเชพเชเซ เชเชพเชฎ เชเชฐเชตเชพเชจเซเช เชเชพเชฒเซ เชฐเชพเชเซเช เชเซเช.
เชธเซเชฐเซเชธ: www.habr.com