====== Paketinis užduočių vykdymas su GPU (SLURM) ======

Norint pasinaudoti PST skaičiavimo resursais su GPU reikės formuoti užduočių skriptus (.sh):
Labai dažnai GPU mum reiks vykdant mašininio mokymo ir dirbtinio intelekto technologijų modeliams, pažiurėkime kaip pasiruošti PyTorch ir Tensorflow aplinkas ir patikrinti ar bibliotekos gali vykdyti kodą GPU spartinimu.

====== Skriptų su PyTorch ir GPU paleidimas per SLURM ======

Programos vykdymo metu sukuriamas failas gpu.txt su indikatoriumi ir vykdymo laiko momentu:

<code shell test_gpu.sh>
#!/bin/sh
#SBATCH -p gpu
#SBATCH -n1
#SBATCH --gres gpu

. gpu_env/bin/activate
python3 test.py
</code>

Pasinagrinėkime pavyzdį paeilučiui:
<code shell>
$ #SBATCH -p gpu 
</code>
nukreipiama į PST su vaizdo plokščių resursais skaičiavimo resursą.

<code shell>
$ #SBATCH -n1
</code>
nurodome, koks CPU poreikis bus reikalingas

<code shell>
$ #SBATCH --gres gpu
</code>
nurodome, koks GPU poreikis bus reikalingas (esant N GPU poreikiui būtų nurodoma gpu:N).


<code shell>
$ . gpu_env/bin/activate
</code>
pasiruošiame aplinką darbui (pirmą kartą ją reikia sukurti atskirai žr. aplinka.sh)

<code shell>
$ python3 test.py
</code>
Kviečiame savo kodo skriptą, atlikti užduočiai su Python



Čia iškviečiamo Python kalbos skripto kodas, iškviečiant Pytorch biblioteką ir patikrinat GPU prieigą, kurios dažniausiai reikia kuriant mašininio mokymo modelius.

<code shell test.py>
import torch
import time

val = torch.cuda.is_available()

f = open("gpu.txt", "a")
ts = time.time()
f.write("GPU is loaded {} at {}\n".format(val, ts))
f.close()
</code>



Čia iškviečiamo Python kalbos skripto kodas, iškviečiant Pytorch biblioteką ir patikrinat GPU prieigą, kurios dažniausiai reikia kuriant mašininio mokymo modelius.

<code shell aplinka.sh>
#!/bin/bash

python3 -m venv gpu_env

# pirmą kartą susirašome reikiamas bibliotekas savo projektui pvz:

pip3 install wheel
pip3 install pillow scikit-image
pip3 install numba 
pip3 install torch torchvision torchaudio

</code>


====== Skriptų su Tensorflow/Keras ir GPU paleidimas per SLURM ======

Programos vykdymo metu sukuriamas failas gpu.txt su indikatoriumi ir vykdymo laiko momentu:

<code shell test_gpu_tf.sh>
#!/bin/sh
#SBATCH -p gpu
#SBATCH -n1
#SBATCH --gres gpu

export PATH=$HOME/miniconda3/bin:$PATH
export CONDA_PREFIX=$HOME/miniconda3/envs/gpu_env
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib/
. activate base
conda activate gpu_env


python3 test_tf.py
</code>

Pasinagrinėkime pavyzdį paeilučiui:
<code shell>
$ #SBATCH -p gpu 
</code>
nukreipiama į PST su vaizdo plokščių resursais skaičiavimo resursą.

<code shell>
$ #SBATCH -n1
</code>
nurodome, koks CPU poreikis bus reikalingas

<code shell>
$ #SBATCH --gres gpu
</code>
nurodome, koks GPU poreikis bus reikalingas (esant N GPU poreikiui būtų nurodoma gpu:N).


<code shell>
$ export PATH=$HOME/miniconda3/bin:$PATH
$ export CONDA_PREFIX=$HOME/miniconda3/envs/gpu_env
$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib/
$ . activate base
$ conda activate gpu_env
</code>
pasiruošiame aplinką darbui (pirmą kartą ją reikia sukurti atskirai žr. aplinka_tf.sh)

<code shell>
$ python3 test_tf.py
</code>
Kviečiame savo kodo skriptą, atlikti užduočiai su Python



Čia iškviečiamo Python kalbos skripto kodas, iškviečiant Tensorflow biblioteką ir patikrinat GPU prieigą, kurios dažniausiai reikia kuriant mašininio mokymo modelius.

<code shell test_tf.py>
import time
import tensorflow as tf

val = tf.test.is_gpu_available()

f = open("gpu.txt", "a")
ts = time.time()
f.write("GPU is loaded {} at {}\n".format(val, ts))
f.close()
</code>



Čia iškviečiamo Python kalbos skripto kodas, iškviečiant Tensorflow biblioteką ir patikrinat GPU prieigą, kurios dažniausiai reikia kuriant mašininio mokymo modelius.

<code shell aplinka_tf.sh>
#!/bin/bash

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh
bash Miniconda3-latest-Linux-x86_64.sh
# yes - on install, no - in init, path default one

export PATH=~/miniconda3/bin:$PATH
conda create --name gpu_env python=3.9
. activate base
conda activate gpu_env
conda install -c conda-forge cudatoolkit=11.7 cudnn=8.1.0
export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:$CONDA_PREFIX/lib/


# pirmؤ… kartؤ… susiraإ،ome reikiamas bibliotekas
pip3 install wheel
pip3 install pillow scikit-image
pip3 install tensorflow

</code>




====== GPU išnaudojimas lygiagretinant kodą su Numba biblioteka ======

=== Įvadas į CUDA Python su Numba  ===

CUDA skaičiavimo biblioteka įgalina programų pagreitinimą, vykdant skaičiavimus ant GPU. 

**Numba** yra "vykdymo-realiu-laiku" Python funkcijų kompiliatorius, Python funkcijoms paspartinti. **Numba** dažnai naudojama Python programuotojų norint, norintiems GPU paspartinti savo programas, jų neperašant į C/C++ kodą, ypač jei kodas jau naudoja **NumPy** masyvuos. 


=== Pavyzdžiai darbas su Numba: Pvz. 1  ===

Pavydžiui, realizuokime Pitagorinę sudėtį:

https://en.wikipedia.org/wiki/Hypot

<code shell>
# importuojame jit kompiliatorių
from numba import jit
import numpy as np
import math

# Sintaksė @jit ekvivalentu užrašui `hypot = jit(hypot)`.
@jit
def hypot(x, y):
    x = abs(x);
    y = abs(y);
    t = min(x, y);
    x = max(x, y);
    t = t / x;
    return x * math.sqrt(1+t*t)


# Bandome
hypot(3.0, 4.0)


# Nesukompiliuotos su *jit* funkcijos iškvietimas
ypot.py_func(3.0, 4.0)

</code>

Gauti metodų vykdymo laikus galėtume atitinkamai pvz:

<code shell>
timeit hypot.py_func(3.0, 4.0)

timeit hypot(3.0, 4.0)
</code>

=== Pavyzdžiai darbas su Numba: Pvz. 2  ===

Parašykime programą pi vertinimui Monte Karlo metodu (žr. https://academo.org/demos/estimating-pi-monte-carlo/)

<code shell>
from numba import jit 
import random

@jit 
def monte_carlo_pi(nsamples):
    acc = 0
    for i in range(nsamples):
        x = random.random()
        y = random.random()
        if (x**2 + y**2) < 1.0:
            acc += 1
    return 4.0 * acc / nsamples



import matplotlib.pyplot as plt


nsamples = 1000000

n = [2**i for i in range(0, 20)]
pi_values = [monte_carlo_pi(i) for i in n]

plt.plot(n, pi_values)
plt.axhline(y=np.pi, color='r', linestyle='-')
plt.xscale('log')
plt.xlabel("Bandymų skaičius n")
plt.ylabel("pi įvertis")
</code>


Gauti metodų vykdymo laikus galėtume atitinkamai pvz:

<code shell>
timeit monte_carlo_pi(nsamples)

timeit monte_carlo_pi.py_func(nsamples)
</code>


=== Kaip Numba veikia?  ===

Numba kompiliatorius atsivželgia į duomenų tipus ir optimizuoja tarpinius skaičiavimu (angl. Intermediate representation (IR))


### **Numba** optimizuojant kodą skirtą GPU naudojant **NumPy** universalias funkcijas (ufuncs)
Toliau laikysime GPU programavimo aprėpyje jog dirbsime su NumPy universaliomis funkcijas (arba ufuncs) - t.y. standartinės bibliotekos funkcijos žr. dokumentaciją:   https://docs.scipy.org/doc/numpy-1.15.1/reference/ufuncs.html

=== Pavyzdžiai darbas su Numba: Pvz. 3  ===

<code shell>

import numpy as np

a = np.array([1, 2, 3, 4])
b = np.array([10, 20, 30, 40])

np.add(a, b)


# Universalios funkcijos veikia su vektoriais ir skaičiais
np.add(a, 100)


# Matriciniu atveju, vektoriai taikomi sąrašo elementams t.y. eilutėms
c = np.arange(4*4).reshape((4,4))
print('c:', c)

np.add(b, c)
</code>



=== Universalių funkcijų kūrimas ir optimizavimas  ===


Svarbu suprasti, jog norint kurti universalias fukcijas, tokias turime ir naudoti. Šiuo atveju, tam mum bus reikalinkas metodas *vectorize*.

Šiame pačiame pirmame pavyzdyje naudosime *vectorize*, kad sudarytume ir optimizuotume sukurtą universalią funkciją **CPU**



<code shell>
from numba import vectorize

@vectorize
def add_ten(num):
    return num + 10

nums = np.arange(10)
nums

add_ten(nums)

# Dabar norint išnaudoti **GPU** optimizavimą mum reikia 
@vectorize(['int64(int64, int64)'], target='cuda') 
def add_ufunc(x, y):
    return x + y

add_ufunc(a, b)
</code>


Gauti metodų vykdymo laikus galėtume atitinkamai pvz:

<code shell>
timeit np.add(b, c)   # NumPy - CPU

timeit add_ufunc(b, c) # Numba - GPU
</code>

# Ant CPU veikia greičiau :) 
# 1. duomenys per maži
# 2. operacijos primityvios
# 3. kopijuojame duomenis į GPU
# 4. naudojame didelius duomenis (int64)


=== Pavyzdžiai darbas su Numba: Pvz. 4  ===

Panagrinėkime sudėtingesnį atvejį f(x|\mu, \sigma) = \frac{e^{-((x-\mu)/\sigma)^2}}{\sigma \sqrt{2\pi}}

<code shell>


import math 

SQRT_2PI = np.float32((2*math.pi)**0.5) 

@vectorize(['float32(float32, float32, float32)'], target='cuda')
def gaussian_pdf(x, mean, sigma):
    return math.exp(-0.5 * ((x - mean) / sigma)**2) / (sigma * SQRT_2PI)



import numpy as np

x = np.random.uniform(-3, 3, size=1000000).astype(np.float32)
x = np.sort(x)

mean = np.float32(0.0)
sigma = np.float32(1.0)


f = gaussian_pdf(x, 0.0, 1.0)



plt.plot(x, f)
plt.xlabel('x')
plt.ylabel('f(x)')
</code>

Gauti metodų vykdymo laikus galėtume atitinkamai pvz:

<code shell>
timeit gaussian_pdf(x, mean, sigma)

import scipy.stats 
norm_pdf = scipy.stats.norm
timeit norm_pdf.pdf(x, loc=mean, scale=sigma)
</code>




=== Pavyzdžiai darbas su Numba: Pvz. 5  ===

Tais atvejais, kai norime spartinti vektorinius skaičiavimus, o ne skaičiavimus paelemenčiui -- naudoti *numba.cuda.jit*


<code shell>

from numba import cuda

@cuda.jit(device=True)
def polar_to_cartesian(rho, theta):
    x = rho * math.cos(theta)
    y = rho * math.sin(theta)
    return x, y

@vectorize(['float32(float32, float32, float32, float32)'], target='cuda')
def polar_distance(rho1, theta1, rho2, theta2):
    x1, y1 = polar_to_cartesian(rho1, theta1) 
    x2, y2 = polar_to_cartesian(rho2, theta2)
    
    return ((x1 - x2)**2 + (y1 - y2)**2)**0.5


n = 1000000
rho1 = np.random.uniform(0.5, 1.5, size=n).astype(np.float32)
theta1 = np.random.uniform(-np.pi, np.pi, size=n).astype(np.float32)
rho2 = np.random.uniform(0.5, 1.5, size=n).astype(np.float32)
theta2 = np.random.uniform(-np.pi, np.pi, size=n).astype(np.float32)


polar_distance(rho1, theta1, rho2, theta2)
</code>


=== Plačiau apie GPU išnaudojimą  ===


 * [[https://klevas.mif.vu.lt/~linp/hpc/ | Medžiaga ir pavyzdžiai: klevas.mif.vu.lt/~linp/hpc/ ]]

 * [[https://drive.mif.vu.lt/s/9Zpzxzq4XCyMozp|GPU skaičiavimai HPC insfrastruktūroje (video) ]]