Stavba nového PC pre dátovú analytiku a programovanie (nielen) v R

Základná doska: ASUS ROG Strix B650-E Gaming WiFi

Táto doska ponúka najnovší AMD socket AM5, podporu pre PCIe 5.0 a DDR5 RAM. Má vynikajúce možnosti pripojenia, vrátane Wi-Fi 6E, Bluetooth 5.2, 2,5GB sieťovkou a množstvo USB portov. Podpora pre najnovšie technológie zabezpečuje vysokú priepustnosť dát a rýchlejšiu komunikáciu medzi komponentmi. Jedna z nevýhod moderných (najmä ASUS) základných dosiek je, že púšťajú zbytočne vysoké napätie do procesora. Toto bol aj môj prípad, preto som musel dodatočne aktualizovať BIOS a spraviť undervolting.

Procesor: AMD Ryzen 9 7900X

12-jadrový procesor s 24 vláknami a vysokou frekvenciou 4,7 GHz, v booste až 5,6 Ghz. Podporuje (len) DDR5 operačné pamäte. V čase keď som vyberal procesor bola dostupná už novšia generácia AMD procesorov rady 9000 so Zen 5 architektúrou. Recenzie boli však skôr “vlažné” a ako lepšia voľba sa stále javí táto staršia generácia procesorov (aj vzhľadom na pomer cena/výkon). V konečnom dôsledku je tento procesor ideálny pre moje potreby. Viac jadier a vlákien umožňuje paralelné spracovanie úloh, čo je pri práci s dátami a trénovaní ML modelov neoceniteľné. Zrýchľuje to výpočty a znižuje čas čakania. Rovnako jednovláknový výkon je skvelý, hoci nie na úrovni procesorov od Intelu.

Tu by som sa ešte pristavil pri otázke, prečo teda nie procesor od Intelu. Mimo toho, že aktuálny socket 1700 je už viac menej výbehový, vyššie rady (i7 a i9) 13. a 14. generácie majú veľké problémy s nestabilitou a oxidáciou.

RAM: 64 GB Kingston Fury DDR5 6000MHz CL30

Jedná sa o vysokorýchlostnú DDR5 pamäť s nízkou latenciou. Malo by sa jednať o ideálne parametre pre vybraný procesor. Default nastavenie je však obmedzené na 4800MHz. Pre využitie plnej rýchlosti je nutné povoliť EXPO I profil v BIOSe.

Veľká kapacita RAM umožňuje pracovať s rozsiahlymi datasetmi priamo v pamäti bez nutnosti swapovania na disk. Rýchlosť a nízka latencia zlepšujú výkon pri spracovaní dát a zvyšujú efektivitu ML algoritmov.

SSD: M.2 WD Black SN770 1 TB

Rýchly NVMe SSD disk s vysokými rýchlosťami čítania a zápisu.

Rýchle úložisko je kľúčové pre načítanie veľkých dátových súborov a rýchly prístup k nim. To znižuje latenciu pri vstupno-výstupných operáciách a zrýchľuje celkový proces spracovania dát.

Grafická karta: Inno3D GeForce RTX 4060 Ti Twin X2 OC

Grafická karta nižšej strednej triedy s podporou pre CUDA jadra a ray tracing. Má 8 GB RAM typu GDDR6 a 4352 CUDA jadier.

GPU môže výrazne zrýchliť trénovanie ML modelov, najmä v oblastiach ako hlboké učenie, ale dá sa použiť aj na akceleráciu tradičných algoritmov ako XGBoost alebo LightGBM. V mojom prípade bude jej primárne určenie práve na učenie sa nových knižníc potrebných pre akceleráciu tréningu a optimalizáciu algoritmov a ich hyperparametrov.

Chladenie: NZXT Kraken 240mm AiO

Výkonné all in one (AiO) vodné chladenie s 240mm radiátorom a displejom zobrazujúcim teplotu CPU.

Udržiava procesor pri nízkych teplotách, čo umožňuje udržať vysoký výkon bez throttlingu. Stabilné teploty sú dôležité pri dlhotrvajúcich výpočtoch a trénovaní modelov. 240 mm rozmer som vyberal s ohľadom na vybranú PC skrinku a možnosť montáže chladenia zvrchu, aby teplý vzduch odvádzal cez radiátor von.

Tento model, podobne ako väčšina AiO chladičov, prichádza s predaplikovanou termálnou pastou. Pri procesoroch AMD rady 7000 aj 9000 je menším problémom ich tvar. Keďže majú na sebe “výrezy”, prebytočná termálna pasta sa do nich môže dostať. Nemala by síce nič poškodiť, ale existuje relatívne lacné riešenie (hoci sa jedná len o kus plastu). Je ním Noctua NA-TPG1.

Alternatívou bolo vzduchové chladenie Noctua NH-D1. Nebol som si však istý či sa vojde do skrinky s relatívne vysokými RAM. Navyše ako človeku, ktorý má rád dáta mi zobrazovanie teplôt na displeji robí radosť.

Zdroj: Seasonic Focus GX-750

Kvalitný 750W plne modulárny zdroj s 80+ Gold certifikáciou.

Stabilné a spoľahlivé napájanie je nevyhnutné pre bezproblémovú prevádzku systému, najmä pri vysokom zaťažení. Umožňuje tiež budúce upgrady komponentov bez nutnosti výmeny zdroja (napr výkonnejší procesor alebo grafickú kartu).

Skrinka: Fractal Design North

Štýlová skrinka s drevenými prvkami, výborným prietokom vzduchu a možnosťami pre “cable management”. Dobrý prietok vzduchu zlepšuje chladenie komponentov, čo prispieva k stabilite a výkonu systému. Skrinka obsahuje dva 140 mm ventilátory. K nim je nutné ešte dokúpiť aspoň jeden 120 mm ventilátor na odvod vzduchu zo zadnej strany skrinky. Ten som vybral Cooler Master MasterFan Mf120 HALO s ARGB (adresovateľné RGB osvetlenie).

Metódy

Pre porovnanie výkonu starého PC a novej zostavy som sa zameral na dva konkrétne aspekty:

• Rýchlosť načítania dát: Testoval som načítanie 4,2 GB CSV súboru so 113,6 miliónmi riadkov a 8 stĺpcami pomocou základnej funkcie read.csv(), read_csv() funkcie z knižnice readr a fread() funkcie z data.table. Primárnymi faktormi ovplyvňujúcimi výkon sú rýchlosť SSD (rýchlosť čítania a zápisu) a veľkosť RAM kvôli swapovaniu.

• Výkon CPU: Pomocou algoritmu na generovanie prvočísel (Sieve of Eratosthenes) som porovnal jednojadrový výkon a viacjadrové paralelné spracovanie. Tento test prebehol v základnej for slučke a tiež v paralelných procesoch s rôznymi počtami vlákien (7 vlákien na oboch zostavách a 23 vlákien na novej zostave). Tento benchmark bol inšpirovaný týmto článkom na medium a touto diskusiou na stackoverflow. Testoval som tri rôzne prístupy:

  • For loop – zameraný na jednojadrový výkon.
  • parLapply – zameraný na viacjadrový výkon.
  • foreach – zameraný na viacjadrový výkon.

Všetky testy boli zbiehané v piatich iteráciách pomocou funkcie mark z knižnice bench:

# Required Libraries
library(bench)       # Benchmarking tools
library(readr)       # Fast CSV reader
library(data.table)  # Fast data manipulation
library(dplyr)       # Data manipulation tools
library(doParallel)  # Parallel computing tools

# Part 1: Loading a large CSV file
# This tests the speed of different file loading methods (base R, readr, and data.table),
# with SSD speed and RAM performance being the key factors influencing the results.

# Base R CSV loading
results_csv_load_base <- mark(
  read.csv("custom_1988_2020.csv"),   # Load CSV with base R's read.csv
  iterations = 5,                     # Number of benchmark iterations
  time_unit = 's'                     # Measure time in seconds
) |> 
  select(`min time` = min,            # Extract relevant metrics
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

gc()  # Clear memory

# Readr CSV loading
results_csv_load_readr <- mark(
  read_csv("custom_1988_2020.csv"),   # Load CSV with readr's read_csv
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

gc()

# Data.table CSV loading
results_csv_load_datatable <- mark(
  fread("custom_1988_2020.csv"),      # Load CSV with data.table's fread
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

gc()

# Adding a column to distinguish the method used
results_csv_load_base$lib <- "base"
results_csv_load_readr$lib <- "readr"
results_csv_load_datatable$lib <- "fread"

# Combine the results from different loading methods into one data frame
results_data_load <- bind_rows(
  results_csv_load_base,
  results_csv_load_readr,
  results_csv_load_datatable
)

# Save the results for future comparison
write_rds(results_data_load, "results_data_load.RDS")

# Display the results as a table
knitr::kable(
  results_data_load |> 
    mutate(across(c(1, 2, 4), ~ round(.x, 2)))
)

# Part 2: Testing CPU Performance with a Prime Sieve Algorithm
# The sieve function is a CPU-bound operation that generates a list of prime numbers up to n.
# This tests single-thread performance in the for-loop version and multi-thread performance in the parallel versions.

# Prime sieve algorithm (generates primes up to n)
sieve <- function(n) {
  n <- as.integer(n)
  primes <- rep(TRUE, n)
  primes[1] <- FALSE
  last.prime <- 2L
  fsqr <- floor(sqrt(n))
  while (last.prime <= fsqr) {
    primes[seq.int(2L * last.prime, n, last.prime)] <- FALSE
    sel <- which(primes[(last.prime + 1):(fsqr + 1)])
    if (any(sel)) {
      last.prime <- last.prime + min(sel)
    } else last.prime <- fsqr + 1
  }
  which(primes)
}

# Single-threaded for loop
result_for_loop <- mark(
  for (i in 10:5e4) {  
    result[[i]] <- sieve(i)          # Run sieve for each value in the range 10 to 50000
  },
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

result_for_loop$method <- "for loop"  # Label for results

gc()

# Multi-threading: parLapply with 7 threads (parallel computing using 7 cores)
registerDoParallel(cores = 7)  # Register 7 cores for parallel processing
cl <- makeCluster(7)

result_par7 <- mark(
  parLapply(cl, 10:5e4, sieve),      # Run the sieve function in parallel on 7 cores
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

stopCluster(cl)                      # Stop the parallel cluster
registerDoSEQ()

gc()
result_par7$method <- "parLapply 7"   # Label for results

# Multi-threading: parLapply with 23 threads (parallel computing using 23 cores)
no_cores <- detectCores() - 1        # Detect available cores minus one
registerDoParallel(cores = no_cores)
cl <- makeCluster(no_cores)

result_par23 <- mark(
  parLapply(cl, 10:5e4, sieve),      # Run the sieve function in parallel on 23 cores
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

stopCluster(cl)
registerDoSEQ()

gc()
result_par23$method <- "parLapply 23"  # Label for results

# Multi-threading: foreach with 7 threads
cl <- makeCluster(7)
registerDoParallel(7)

result_foreach_7 <- mark(
  foreach(i = 10:5e4) %dopar% sieve(i),  # Run sieve in parallel using foreach on 7 cores
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

stopCluster(cl)
registerDoSEQ()

gc()
result_foreach_7$method <- "foreach 7"  # Label for results

# Multi-threading: foreach with 23 threads
cl <- makeCluster(no_cores)
registerDoParallel(cl)

result_foreach_23 <- mark(
  foreach(i = 10:5e4) %dopar% sieve(i),  # Run sieve in parallel using foreach on 23 cores
  iterations = 5,
  time_unit = 's'
) |> 
  select(`min time` = min,
         `median time` = median,
         `total time` = total_time,
         `memory allocated` = mem_alloc)

stopCluster(cl)
registerDoSEQ()

gc()
result_foreach_23$method <- "foreach 23"  # Label for results

# Combine CPU benchmark results
result_sieve <- bind_rows(
  result_for_loop,
  result_par7,
  result_par23,
  result_foreach_7,
  result_foreach_23
)

gc()
write_rds(result_sieve, "result_sieve.RDS")

knitr::kable(
  result_sieve |> 
    mutate(across(c(1:4), ~ round(.x, 2)))
)

Výsledky

Načítanie CSV súboru: Na starom Dell Optiplexe 7050 trvalo načítanie súboru nasledovne:

Na novom PC s Ryzen 7900x boli výsledky výrazne lepšie:

Dramatické zlepšenie nastalo pri všetkých metódach. Najviac, o 83%, pri readr a funkcii read_csv(). Na novej zostave je teraz táto metóda približne na úrovni fread() na starej zostave. Víťazom v načítaní však jednoznačne ostáva práve fread(). Pri tejto metóde je zlepšenie o 76% a spomínaný súbor načíta za neuveriteľné necelé tri sekundy.

CPU test: Výsledky na Dell Optiplex 7050:

Výsledky novej zostavy:

Jednojadrový výkon stúpol o vyše 50%. To je veľmi dobrá správa, kedže R skripty bežia primárne na jednom jadre a paralelizácia sa používa len v prípadoch, keď to dáva zmysel. Paralelné operácie majú totiž určitý “overhead” pri komunikácii medzi vláknami a spracovávaní dát. Ak je tento overhead príliš veľký vzhľadom na zlepšenie z paralelného vykonávania, nemusí byť výkon vždy proporcionálny počtu vlákien, a to vidíme aj na výsledkoch.

Paralelný výkon vzrástol v prípade parLapply o 19% a pri foreach o 61%. Ak si porovnám najvyšší potenciálny výkon na počte dostupných vlákien (7 vs 23), tak sa bavíme o zlepšení 29% pri parLapply a 59% pri foreach. Napriek výrazne väčším zlepšeniam pri foreach je stále rýchlejší parLapply (hoci sa bavíme o desatinách až jednotkách sekúnd), navyše potrebuje výrazne menej pamäte.

Zrejme ste si všimli, že pri foreach došlo na 23 vláknach k poklesu o 2% oproti 7 vláknam. Toto je ukážka toho, že overhead z príliš veľkého počtu vlákien, zdieľané zdroje (operačná pamäť a cache), konkurencia jadier a málo alebo žiadne zdroje pre operačný systém a ostatné procesy môže mitigovať benefit viacerých jadier. V prípade operačnej pamäte sa môžeme stretnúť s odporúčaniami na 2 až 4 GB RAM na vlákno, v prípade tejto zostavy je pomer 2,7. Budúce rozšírenie na 128 GB by v niektorých prípadoch mohlo teda pomôcť.