Ver3.0 ๐ ๋งคํธ๋ฆญ์ค ์ฐ์ฐ ์ต์ ํ: NumPy์ CuPy๋ก ๊ณ ์ฑ๋ฅ ๊ณ์ฐ

๐ ๋งคํธ๋ฆญ์ค ์ฐ์ฐ ์ต์ ํ: NumPy์ CuPy๋ก ๊ณ ์ฑ๋ฅ ๊ณ์ฐ
์น๊ตฌ์ผ, ์ค๋์ ํ๋ ฌ ์ฐ์ฐ์ ๋ฏธ์น๋ฏ์ด ๋น ๋ฅด๊ฒ ๋ง๋๋ ๋น๋ฒ์ ์๋ ค์ค๊ฒ! ๐จ
์ผ, ํน์ ๋๋ ๋ฐ์ดํฐ ๋ถ์ํ๋ค๊ฐ ์ปดํจํฐ๊ฐ ๋ฉ์ถ ๊ฒ์ฒ๋ผ ๋๊ปด์ง ์ ์์ด? ๐
ํนํ ํฐ ํ๋ ฌ ๊ณ์ฐํ ๋ ๋ง์ด์ผ. ์ปคํผ ํ ์ ๋ง์๊ณ ์๋ ์์ง๋ ๋์๊ฐ๊ณ ์๊ณ ...
์ค๋์ ๊ทธ๋ฐ ๋ต๋ตํจ์ ๋ ๋ ค๋ฒ๋ฆด ์ ์๋ ์ต์ ํ ๊ธฐ๋ฒ๋ค์ ํํค์ณ๋ณผ ๊ฑฐ์ผ!
NumPy์ ๊ธฐ๋ณธ๋ถํฐ GPU๋ฅผ ํ์ฉํ CuPy๊น์ง, ์ค์ ์์ ๋ฐ๋ก ์จ๋จน์ ์ ์๋ ๊ฟํ๋ค๋ก ๊ฐ๋ ์ฑ์๋จ์ด. ๐
๐ฏ ์ ๋งคํธ๋ฆญ์ค ์ฐ์ฐ ์ต์ ํ๊ฐ ์ค์ํ ๊น?
์์ฆ ๋จธ์ ๋ฌ๋, ๋ฅ๋ฌ๋, ๋ฐ์ดํฐ ์ฌ์ด์ธ์ค... ์ด๋ฐ ๊ฑฐ ํ๋ ค๋ฉด ํ๋ ฌ ์ฐ์ฐ์ ํ์์์?
๊ทผ๋ฐ ๋ฌธ์ ๋ ๋ฐ์ดํฐ ํฌ๊ธฐ๊ฐ ์ ์ ์ปค์ง๋ค๋ ๊ฑฐ์ง. ๐
์๋ฅผ ๋ค์ด๋ณผ๊ฒ:
- ์ด๋ฏธ์ง ์ฒ๋ฆฌ: 4K ์ด๋ฏธ์ง ํ๋๋ง ํด๋ 3840ร2160 ํฝ์
์ด์ผ
- ์์ฐ์ด ์ฒ๋ฆฌ: BERT ๋ชจ๋ธ์ ์์ต ๊ฐ์ ํ๋ผ๋ฏธํฐ๋ฅผ ๊ฐ์ง๊ณ ์์ด
- ์ถ์ฒ ์์คํ
: ์๋ฐฑ๋ง ์ฌ์ฉ์ ร ์์ญ๋ง ์์ดํ
๋งคํธ๋ฆญ์ค
์ด๋ฐ ๊ฑธ ์ต์ ํ ์์ด ๋๋ฆฌ๋ฉด? ์๊ฐ๋ ์๊ฐ์ด์ง๋ง ์ ๊ธฐ์ธ๋ ์ฅ๋ ์๋์ผ. ๐ธ
๐ NumPy: ํ์ด์ฌ ํ๋ ฌ ์ฐ์ฐ์ ๊ธฐ๋ณธ
NumPy๋ ํ์ด์ฌ์์ ์์น ๊ณ์ฐํ ๋ ๊ฑฐ์ ํ์ค์ฒ๋ผ ์ฐ์ด๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ.
๊ทผ๋ฐ ๋ง์ ์ฌ๋๋ค์ด NumPy๋ฅผ ์ฐ๋ฉด์๋ ์ต์ ํ ๊ธฐ๋ฅ์ ์ ๋๋ก ํ์ฉ ๋ชปํ๋๋ผ๊ณ . ๐
NumPy๊ฐ ๋น ๋ฅธ ์ด์ ๋ ๋ญ๊น?
1๏ธโฃ C์ธ์ด๋ก ๊ตฌํ๋ ์ ์์ค ์ฐ์ฐ
2๏ธโฃ ๋ฒกํฐํ(Vectorization) ์ง์
3๏ธโฃ ๋ฉ๋ชจ๋ฆฌ ํจ์จ์ ์ธ ๋ฐฐ์ด ๊ตฌ์กฐ
4๏ธโฃ BLAS/LAPACK ๊ฐ์ ์ต์ ํ๋ ์ ํ๋์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํ์ฉ
# NumPy ์ค์น
pip install numpy
# ์ํฌํธ
import numpy as np
# ๋ฒ์ ํ์ธ
print(np.__version__) # 1.24.0 ์ด์ ๊ถ์ฅ
์ด๋ณด์๋ค์ด ๊ฐ์ฅ ๋ง์ด ํ๋ ์ค์๊ฐ ๋ญ์ง ์์? ๋ฐ๋ก for ๋ฃจํ๋ฅผ ๋จ๋ฐํ๋ ๊ฑฐ์ผ. ๐
โโ๏ธ
ํ์ด์ฌ์ for ๋ฃจํ๋ ์ ๋ง์ ๋ง ๋๋ ค. ํนํ ํฐ ๋ฐฐ์ด์ ๋ค๋ฃฐ ๋๋ ๋ง์ด์ผ.
๋ฒกํฐํ๋ ์ด๋ฐ ๋ฃจํ๋ฅผ NumPy์ ๋ด์ฅ ์ฐ์ฐ์ผ๋ก ๋ฐ๊พธ๋ ๊ฑฐ์ผ.
ํ ๋ฒ ๋น๊ตํด๋ณผ๊น?
import numpy as np
import time
# 100๋ง ๊ฐ ์์๋ฅผ ๊ฐ์ง ๋ฐฐ์ด
arr = np.random.rand(1000000)
result = np.zeros(1000000)
# ๋ฃจํ๋ก ์ ๊ณฑ ๊ณ์ฐ
start = time.time()
for i in range(len(arr)):
result[i] = arr[i] ** 2
end = time.time()
print(f"๋ฃจํ ๋ฐฉ์: {end - start:.4f}์ด") # ์ฝ 0.5์ด
import numpy as np
import time
arr = np.random.rand(1000000)
# ๋ฒกํฐํ๋ ์ฐ์ฐ
start = time.time()
result = arr ** 2
end = time.time()
print(f"๋ฒกํฐํ ๋ฐฉ์: {end - start:.4f}์ด") # ์ฝ 0.002์ด
์ด๊ฒ ๋ฐ๋ก NumPy์ ์ง์ง ํ์์ผ. ๋จ์ํ ํธ๋ฆฌํ ๊ฒ ์๋๋ผ ์์ฒญ๋๊ฒ ๋น ๋ฅธ ๊ฑฐ์ง.
๐จ ๋ธ๋ก๋์บ์คํ : ์ฐจ์์ด ๋ฌ๋ผ๋ ๊ด์ฐฎ์
๋ธ๋ก๋์บ์คํ
์ NumPy์ ์ ๋ง ๋ฉ์ง ๊ธฐ๋ฅ ์ค ํ๋์ผ. ๐ญ
ํฌ๊ธฐ๊ฐ ๋ค๋ฅธ ๋ฐฐ์ด๋ผ๋ฆฌ๋ ์๋์ผ๋ก ๋ง์ถฐ์ ์ฐ์ฐํ ์ ์๊ฒ ํด์ฃผ๊ฑฐ๋ .
์๋ฅผ ๋ค์ด, (3, 4) ํฌ๊ธฐ์ ํ๋ ฌ๊ณผ (4,) ํฌ๊ธฐ์ ๋ฒกํฐ๋ฅผ ๋ํ ์ ์์ด.
NumPy๊ฐ ์์์ ๋ฒกํฐ๋ฅผ ํ์ฅํด์ ๊ณ์ฐํด์ฃผ๋ ๊ฑฐ์ง!
import numpy as np
# 2D ๋ฐฐ์ด (3x4)
matrix = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12]])
# 1D ๋ฐฐ์ด (4,)
vector = np.array([1, 0, 1, 0])
# ๋ธ๋ก๋์บ์คํ
์ผ๋ก ๊ฐ ํ์ ๋ฒกํฐ ๋ํ๊ธฐ
result = matrix + vector
print(result)
# [[ 2 2 4 4]
# [ 6 6 8 8]
# [10 10 12 12]]
2. ๊ฐ ์ฐจ์์ ํฌ๊ธฐ๊ฐ ๊ฐ๊ฑฐ๋, ๋ ์ค ํ๋๊ฐ 1์ด๋ฉด ํธํ๋จ
3. ํธํ๋์ง ์์ผ๋ฉด ์๋ฌ ๋ฐ์
์์:
- (3, 4) + (4,) โ (3, 4) + (1, 4) โ OK โ
- (3, 4) + (3, 1) โ OK โ
- (3, 4) + (3,) โ (3, 4) + (1, 3) โ Error โ
import numpy as np
# RGB ์ด๋ฏธ์ง (๋์ด, ๋๋น, ์ฑ๋)
image = np.random.randint(0, 256, size=(1080, 1920, 3))
# ๊ฐ ์ฑ๋๋ณ ํ๊ท ๊ณผ ํ์คํธ์ฐจ
mean = np.array([123.68, 116.78, 103.94]) # (3,)
std = np.array([58.40, 57.12, 57.38]) # (3,)
# ๋ธ๋ก๋์บ์คํ
์ผ๋ก ์ ๊ทํ
# (1080, 1920, 3) - (3,) โ ์๋์ผ๋ก ํ์ฅ๋จ!
normalized = (image - mean) / std
print(f"์๋ณธ shape: {image.shape}")
print(f"์ ๊ทํ ํ shape: {normalized.shape}")
print(f"ํ๊ท : {normalized.mean(axis=(0,1))}") # ๊ฑฐ์ 0์ ๊ฐ๊น์
๐พ ๋ฉ๋ชจ๋ฆฌ ์ต์ ํ: dtype๊ณผ ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์
ํฐ ๋ฐ์ดํฐ๋ฅผ ๋ค๋ฃฐ ๋๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ์ ๋ง ์ค์ํด. ๐พ
NumPy๋ ๋ค์ํ ๋ฐ์ดํฐ ํ์
์ ์ง์ํ๋๋ฐ, ์ ์ ํ ํ์
์ ์ ํํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํฌ๊ฒ ์ ์ฝํ ์ ์์ด!
import numpy as np
size = 1000000
# float64 (๊ธฐ๋ณธ๊ฐ) - 8๋ฐ์ดํธ
arr_f64 = np.random.rand(size)
print(f"float64: {arr_f64.nbytes / 1024 / 1024:.2f} MB") # ์ฝ 7.63 MB
# float32 - 4๋ฐ์ดํธ
arr_f32 = np.random.rand(size).astype(np.float32)
print(f"float32: {arr_f32.nbytes / 1024 / 1024:.2f} MB") # ์ฝ 3.81 MB
# float16 - 2๋ฐ์ดํธ
arr_f16 = np.random.rand(size).astype(np.float16)
print(f"float16: {arr_f16.nbytes / 1024 / 1024:.2f} MB") # ์ฝ 1.91 MB
# int8 - 1๋ฐ์ดํธ (0~255 ๋ฒ์๋ง ํ์ํ ๋)
arr_i8 = np.random.randint(0, 256, size, dtype=np.int8)
print(f"int8: {arr_i8.nbytes / 1024 / 1024:.2f} MB") # ์ฝ 0.95 MB
- float64: ๊ณผํ ๊ณ์ฐ, ๊ธ์ต ๋ฐ์ดํฐ
- float32: ๋ฅ๋ฌ๋, ๊ทธ๋ํฝ์ค
- float16: ๋ชจ๋ฐ์ผ ๋ฅ๋ฌ๋, ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ด ์ฌํ ๊ฒฝ์ฐ
NumPy ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฅ๋๋ ๋ฐฉ์์ด ๋ ๊ฐ์ง์ผ.
- C-order (row-major): ํ ์ฐ์ ์ ์ฅ (๊ธฐ๋ณธ๊ฐ)
- F-order (column-major): ์ด ์ฐ์ ์ ์ฅ (Fortran ์คํ์ผ)
์ด๋ค ์์๋ก ์ ๊ทผํ๋๋์ ๋ฐ๋ผ ์ฑ๋ฅ์ด ๋ฌ๋ผ์ง ์ ์์ด! ๐โโ๏ธ
import numpy as np
import time
# ํฐ ๋ฐฐ์ด ์์ฑ
size = 10000
# C-order (๊ธฐ๋ณธ)
arr_c = np.random.rand(size, size)
print(f"C-order flags: {arr_c.flags['C_CONTIGUOUS']}") # True
# F-order
arr_f = np.asfortranarray(arr_c)
print(f"F-order flags: {arr_f.flags['F_CONTIGUOUS']}") # True
# ํ ๋จ์ ์ ๊ทผ (C-order๊ฐ ์ ๋ฆฌ)
start = time.time()
for i in range(size):
_ = arr_c[i, :].sum()
c_row_time = time.time() - start
start = time.time()
for i in range(size):
_ = arr_f[i, :].sum()
f_row_time = time.time() - start
print(f"ํ ์ ๊ทผ - C-order: {c_row_time:.4f}์ด")
print(f"ํ ์ ๊ทผ - F-order: {f_row_time:.4f}์ด")
# ์ด ๋จ์ ์ ๊ทผ (F-order๊ฐ ์ ๋ฆฌ)
start = time.time()
for i in range(size):
_ = arr_c[:, i].sum()
c_col_time = time.time() - start
start = time.time()
for i in range(size):
_ = arr_f[:, i].sum()
f_col_time = time.time() - start
print(f"์ด ์ ๊ทผ - C-order: {c_col_time:.4f}์ด")
print(f"์ด ์ ๊ทผ - F-order: {f_col_time:.4f}์ด")
๐ฅ ๊ณ ๊ธ NumPy ์ต์ ํ ๊ธฐ๋ฒ
einsum์ NumPy์ ์จ๊ฒจ์ง ๋ณด์ ๊ฐ์ ํจ์์ผ. ๐
๋ณต์กํ ํ
์ ์ฐ์ฐ์ ๊ฐ๊ฒฐํ๊ณ ๋น ๋ฅด๊ฒ ํํํ ์ ์์ด.
์ฒ์์ ์ด๋ ค์ ๋ณด์ด์ง๋ง, ์ต์ํด์ง๋ฉด ์ ๋ง ๊ฐ๋ ฅํด!
import numpy as np
A = np.random.rand(100, 200)
B = np.random.rand(200, 300)
# ์ผ๋ฐ์ ์ธ ํ๋ ฌ ๊ณฑ์
result1 = np.dot(A, B)
# einsum ์ฌ์ฉ
result2 = np.einsum('ij,jk->ik', A, B)
# ๊ฒฐ๊ณผ๋ ๋์ผ
print(np.allclose(result1, result2)) # True
# ํ์ง๋ง einsum์ด ๋ ์ ์ฐํด!
# ๋๊ฐํฉ (trace)
matrix = np.random.rand(100, 100)
trace1 = np.trace(matrix)
trace2 = np.einsum('ii->', matrix)
print(np.allclose(trace1, trace2)) # True
# ๋ฐฐ์น ํ๋ ฌ ๊ณฑ์
batch = np.random.rand(10, 50, 50) # 10๊ฐ์ 50x50 ํ๋ ฌ
result = np.einsum('bij,bjk->bik', batch, batch)
print(result.shape) # (10, 50, 50)
- 'ij': ์ฒซ ๋ฒ์งธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค (iํ, j์ด)
- 'jk': ๋ ๋ฒ์งธ ๋ฐฐ์ด์ ์ธ๋ฑ์ค (jํ, k์ด)
- '->ik': ๊ฒฐ๊ณผ ๋ฐฐ์ด์ ์ธ๋ฑ์ค (iํ, k์ด)
- ๋ฐ๋ณต๋๋ ์ธ๋ฑ์ค(j)๋ ์๋์ผ๋ก ํฉ์ฐ๋จ!
NumPy์์ ๋ฐฐ์ด์ ๋ค๋ฃฐ ๋ ๋ทฐ์ ๋ณต์ฌ์ ์ฐจ์ด๋ฅผ ์๋ ๊ฒ ์ ๋ง ์ค์ํด. ๐ญ
๋ทฐ๋ ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๊ณต์ ํ๊ณ , ๋ณต์ฌ๋ ์๋ก์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ฑฐ๋ .
๋ถํ์ํ ๋ณต์ฌ๋ ๋ฉ๋ชจ๋ฆฌ ๋ญ๋น๊ณ ์ฑ๋ฅ ์ ํ์ ์์ธ์ด์ผ!
import numpy as np
original = np.arange(1000000)
# ๋ทฐ ์์ฑ (๋ฉ๋ชจ๋ฆฌ ๊ณต์ )
view = original[::2] # ์ฌ๋ผ์ด์ฑ์ ๋ทฐ๋ฅผ ๋ฐํ
print(f"๋ทฐ์ธ๊ฐ? {view.base is original}") # True
# ๋ทฐ ์์ ํ๋ฉด ์๋ณธ๋ ๋ณ๊ฒฝ๋จ
view[0] = 999
print(original[0]) # 999
# ๋ณต์ฌ ์์ฑ (์๋ก์ด ๋ฉ๋ชจ๋ฆฌ)
copy = original.copy()
print(f"๋ณต์ฌ์ธ๊ฐ? {copy.base is None}") # True
# ๋ณต์ฌ ์์ ํด๋ ์๋ณธ์ ์์
copy[0] = 777
print(original[0]) # 999 (๋ณํ์ง ์์)
# ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ํ์ธ
import sys
print(f"์๋ณธ: {sys.getsizeof(original)} bytes")
print(f"๋ทฐ: {sys.getsizeof(view)} bytes") # ์์
print(f"๋ณต์ฌ: {sys.getsizeof(copy)} bytes") # ์๋ณธ๊ณผ ๋น์ท
- ๋ฉ๋ชจ๋ฆฌ ์ ์ฝ์ด ์ค์ํ ๋
- ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ์์ ํด๋ ๊ด์ฐฎ์ ๋
- ์ฝ๊ธฐ ์ ์ฉ ์์
๋ณต์ฌ ์ฌ์ฉ:
- ์๋ณธ ๋ฐ์ดํฐ๋ฅผ ๋ณด์กดํด์ผ ํ ๋
- ๋ ๋ฆฝ์ ์ธ ๋ฐฐ์ด์ด ํ์ํ ๋
- ํจ์์ ์ ๋ฌํ ๋ ๋ถ์์ฉ์ ํผํ๊ณ ์ถ์ ๋
import numpy as np
arr = np.random.rand(1000000)
# ์๋ก์ด ๋ฐฐ์ด ์์ฑ (๋ฉ๋ชจ๋ฆฌ 2๋ฐฐ ์ฌ์ฉ)
arr = arr + 1
# ์ธํ๋ ์ด์ค ์ฐ์ฐ (๋ฉ๋ชจ๋ฆฌ ์ ์ฝ)
arr += 1
# ๋ค๋ฅธ ์ธํ๋ ์ด์ค ์ฐ์ฐ๋ค
arr *= 2
arr /= 2
arr **= 2
# NumPy ํจ์์ out ํ๋ผ๋ฏธํฐ ํ์ฉ
result = np.empty_like(arr)
np.add(arr, 10, out=result) # ๊ฒฐ๊ณผ๋ฅผ result์ ์ง์ ์ ์ฅ
np.multiply(arr, 2, out=arr) # ์๊ธฐ ์์ ์ ์ ์ฅ๋ ๊ฐ๋ฅ!
๐ฎ GPU ๊ฐ์: CuPy๋ก ๋ ์์ค๋ฅด๊ธฐ
์, ์ด์ ์ง์ง ๊ฒ์ ์ฒด์ธ์ ๋ฅผ ์๊ฐํ ์๊ฐ์ด์ผ! ๐
CuPy๋ NumPy์ ๊ฑฐ์ ๋์ผํ API๋ฅผ ์ ๊ณตํ๋ฉด์ GPU๋ฅผ ํ์ฉํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ผ.
์ฝ๋ ๋ช ์ค๋ง ๋ฐ๊พธ๋ฉด ์์ญ ๋ฐฐ์์ ์๋ฐฑ ๋ฐฐ๊น์ง ๋นจ๋ผ์ง ์ ์์ด!
ํนํ ๋๊ท๋ชจ ํ๋ ฌ ์ฐ์ฐ, ๋ฅ๋ฌ๋, ๊ณผํ ๊ณ์ฐ์์ ์์ฒญ๋ ์๋ ฅ์ ๋ฐํํ์ง. ๐ช
# CUDA ๋ฒ์ ์ ๋ง๊ฒ ์ค์น (CUDA 11.x ์์)
pip install cupy-cuda11x
# ๋๋ conda ์ฌ์ฉ
conda install -c conda-forge cupy
# ์ค์น ํ์ธ
import cupy as cp
print(cp.__version__)
print(cp.cuda.runtime.getDeviceCount()) # GPU ๊ฐ์ ํ์ธ
- CUDA Toolkit ์ค์น ํ์
- NVIDIA ๋๋ผ์ด๋ฒ ์ต์ ๋ฒ์ ๊ถ์ฅ
- GPU ๋ฉ๋ชจ๋ฆฌ๋ ์ถฉ๋ถํด์ผ ํจ (์ต์ 4GB ์ด์ ๊ถ์ฅ)
import numpy as np
import cupy as cp
import time
# NumPy ๋ฒ์
size = 10000
np_a = np.random.rand(size, size)
np_b = np.random.rand(size, size)
start = time.time()
np_result = np.dot(np_a, np_b)
np_time = time.time() - start
print(f"NumPy ์๊ฐ: {np_time:.4f}์ด")
# CuPy ๋ฒ์ (์ฝ๋๊ฐ ๊ฑฐ์ ๋์ผ!)
cp_a = cp.random.rand(size, size)
cp_b = cp.random.rand(size, size)
start = time.time()
cp_result = cp.dot(cp_a, cp_b)
cp.cuda.Stream.null.synchronize() # GPU ์ฐ์ฐ ์๋ฃ ๋๊ธฐ
cp_time = time.time() - start
print(f"CuPy ์๊ฐ: {cp_time:.4f}์ด")
print(f"์๋ ํฅ์: {np_time / cp_time:.1f}๋ฐฐ")
- NumPy (CPU): ์ฝ 15์ด
- CuPy (GPU): ์ฝ 0.1์ด
- ์๋ ํฅ์: ์ฝ 150๋ฐฐ! ๐ฅ
CPU์ GPU ์ฌ์ด์ ๋ฐ์ดํฐ ์ ์ก์ ๋น์ฉ์ด ๋ค์ด.
๊ทธ๋์ ๊ฐ๋ฅํ๋ฉด GPU์์ ๋ชจ๋ ์ฐ์ฐ์ ๋๋ด๋ ๊ฒ ์ข์! ๐ฏ
import numpy as np
import cupy as cp
import time
# NumPy ๋ฐฐ์ด์ CuPy๋ก ์ ์ก
np_array = np.random.rand(10000, 10000)
start = time.time()
cp_array = cp.asarray(np_array) # CPU โ GPU
transfer_time = time.time() - start
print(f"CPU โ GPU ์ ์ก: {transfer_time:.4f}์ด")
# GPU์์ ์ฌ๋ฌ ์ฐ์ฐ ์ํ (์ ์ก ๋น์ฉ 1ํ๋ง!)
result = cp_array @ cp_array # ํ๋ ฌ ๊ณฑ์
result = cp.sqrt(result) # ์ ๊ณฑ๊ทผ
result = result + 10 # ๋ง์
result = cp.mean(result) # ํ๊ท
# ์ต์ข
๊ฒฐ๊ณผ๋ง CPU๋ก ๊ฐ์ ธ์ค๊ธฐ
start = time.time()
final_result = cp.asnumpy(result) # GPU โ CPU
back_time = time.time() - start
print(f"GPU โ CPU ์ ์ก: {back_time:.4f}์ด")
print(f"์ต์ข
๊ฒฐ๊ณผ: {final_result}")
2. ์ค๊ฐ ๊ฒฐ๊ณผ๋ฅผ CPU๋ก ๊ฐ์ ธ์ค์ง ๋ง ๊ฒ
3. ๋ฐฐ์น ์ฒ๋ฆฌ๋ก ์ ์ก ํ์ ์ต์ํ
4. ์์ ๋ฐ์ดํฐ๋ CPU๊ฐ ๋ ๋น ๋ฅผ ์ ์์ (์ ์ก ๋น์ฉ ๊ณ ๋ ค)
โก ์ค์ ์ต์ ํ ์ ๋ต
๋ฐ์ดํฐ๋ฅผ ํ๋์ฉ ์ฒ๋ฆฌํ๋ ๊ฑด ์ ๋ง ๋นํจ์จ์ ์ด์ผ. ๐
๋ฐฐ์น๋ก ๋ฌถ์ด์ ์ฒ๋ฆฌํ๋ฉด GPU์ ๋ณ๋ ฌ ์ฒ๋ฆฌ ๋ฅ๋ ฅ์ ์ต๋ํ ํ์ฉํ ์ ์์ด!
import cupy as cp
import time
# 1000๊ฐ์ ์ด๋ฏธ์ง (๊ฐ 256x256)
images = cp.random.rand(1000, 256, 256, 3)
# โ ๋์ ๋ฐฉ๋ฒ: ํ๋์ฉ ์ฒ๋ฆฌ
start = time.time()
results = []
for i in range(1000):
img = images[i]
processed = cp.mean(img, axis=2) # RGB โ Grayscale
results.append(processed)
bad_time = time.time() - start
print(f"์์ฐจ ์ฒ๋ฆฌ: {bad_time:.4f}์ด")
# โ
์ข์ ๋ฐฉ๋ฒ: ๋ฐฐ์น ์ฒ๋ฆฌ
start = time.time()
batch_result = cp.mean(images, axis=3) # ํ ๋ฒ์ ์ฒ๋ฆฌ!
good_time = time.time() - start
print(f"๋ฐฐ์น ์ฒ๋ฆฌ: {good_time:.4f}์ด")
print(f"์๋ ํฅ์: {bad_time / good_time:.1f}๋ฐฐ")
GPU ๋ฉ๋ชจ๋ฆฌ ํ ๋น/ํด์ ๋ ๋น์ฉ์ด ๋ง์ด ๋ค์ด.
CuPy์ ๋ฉ๋ชจ๋ฆฌ ํ์ ์ฌ์ฉํ๋ฉด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฌ์ฉํด์ ์ฑ๋ฅ์ ๋์ผ ์ ์์ด! ๐โโ๏ธ
import cupy as cp
# ๋ฉ๋ชจ๋ฆฌ ํ ๊ฐ์ ธ์ค๊ธฐ
mempool = cp.get_default_memory_pool()
pinned_mempool = cp.get_default_pinned_memory_pool()
# ํ์ฌ ์ฌ์ฉ๋ ํ์ธ
print(f"์ฌ์ฉ ์ค์ธ ๋ฉ๋ชจ๋ฆฌ: {mempool.used_bytes() / 1024**2:.2f} MB")
print(f"์ด ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ: {mempool.total_bytes() / 1024**2:.2f} MB")
# ๋ง์ ๋ฐฐ์ด ์์ฑ
arrays = []
for i in range(100):
arr = cp.random.rand(1000, 1000)
arrays.append(arr)
print(f"๋ฐฐ์ด ์์ฑ ํ: {mempool.used_bytes() / 1024**2:.2f} MB")
# ๋ฉ๋ชจ๋ฆฌ ํด์
arrays = None
cp.get_default_memory_pool().free_all_blocks()
print(f"ํด์ ํ: {mempool.used_bytes() / 1024**2:.2f} MB")
์ฌ๋ฌ ์ฐ์ฐ์ ํ๋์ ์ปค๋๋ก ํฉ์น๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ์ ์ค์ผ ์ ์์ด.
CuPy๋ ์๋์ผ๋ก ์ผ๋ถ ์ฐ์ฐ์ ์ตํฉํด์ฃผ์ง๋ง, ์ง์ ์ปค์คํ
์ปค๋์ ๋ง๋ค ์๋ ์์ด! ๐ง
import cupy as cp
# ElementwiseKernel๋ก ์ปค์คํ
์ฐ์ฐ ์ ์
fused_kernel = cp.ElementwiseKernel(
'float32 x, float32 y', # ์
๋ ฅ
'float32 z', # ์ถ๋ ฅ
'z = sqrt(x * x + y * y)', # ์ฐ์ฐ (ํผํ๊ณ ๋ผ์ค)
'fused_kernel' # ์ปค๋ ์ด๋ฆ
)
# ์ฌ์ฉ
x = cp.random.rand(10000000, dtype=cp.float32)
y = cp.random.rand(10000000, dtype=cp.float32)
# ์ปค์คํ
์ปค๋ ์ฌ์ฉ (ํ ๋ฒ์ ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ)
result = fused_kernel(x, y)
# ์ผ๋ฐ ๋ฐฉ์ (์ฌ๋ฌ ๋ฒ์ ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ)
# result = cp.sqrt(x * x + y * y) # ์ด๊ฒ๋ณด๋ค ์๊ฐ ๋ ๋น ๋ฆ!
๐ ์ค์ ์์ : ๋๊ท๋ชจ ํ๋ ฌ ์ฐ์ฐ
์ด์ ์ค์ ๋ก ์ฌ์ฉํ ์ ์๋ ์์ ํ ์์ ๋ฅผ ๋ง๋ค์ด๋ณผ๊ฒ! ๐จ
๋จธ์ ๋ฌ๋์์ ์์ฃผ ์ฐ์ด๋ ํ๋ ฌ ์ฐ์ฐ๋ค์ ์ต์ ํํด๋ณด์.
import numpy as np
import cupy as cp
import time
class LinearRegressionNumPy:
def __init__(self):
self.weights = None
self.bias = None
def fit(self, X, y, learning_rate=0.01, epochs=1000):
n_samples, n_features = X.shape
self.weights = np.zeros(n_features)
self.bias = 0
for epoch in range(epochs):
# ์์ธก
y_pred = np.dot(X, self.weights) + self.bias
# ๊ทธ๋๋์ธํธ ๊ณ์ฐ
dw = (1/n_samples) * np.dot(X.T, (y_pred - y))
db = (1/n_samples) * np.sum(y_pred - y)
# ๊ฐ์ค์น ์
๋ฐ์ดํธ
self.weights -= learning_rate * dw
self.bias -= learning_rate * db
def predict(self, X):
return np.dot(X, self.weights) + self.bias
class LinearRegressionCuPy:
def __init__(self):
self.weights = None
self.bias = None
def fit(self, X, y, learning_rate=0.01, epochs=1000):
n_samples, n_features = X.shape
self.weights = cp.zeros(n_features)
self.bias = 0
for epoch in range(epochs):
y_pred = cp.dot(X, self.weights) + self.bias
dw = (1/n_samples) * cp.dot(X.T, (y_pred - y))
db = (1/n_samples) * cp.sum(y_pred - y)
self.weights -= learning_rate * dw
self.bias -= learning_rate * db
def predict(self, X):
return cp.dot(X, self.weights) + self.bias
# ํ
์คํธ ๋ฐ์ดํฐ ์์ฑ
n_samples = 100000
n_features = 1000
X_np = np.random.rand(n_samples, n_features)
y_np = np.random.rand(n_samples)
X_cp = cp.asarray(X_np)
y_cp = cp.asarray(y_np)
# NumPy ๋ฒ์
model_np = LinearRegressionNumPy()
start = time.time()
model_np.fit(X_np, y_np, epochs=100)
np_time = time.time() - start
print(f"NumPy ํ์ต ์๊ฐ: {np_time:.4f}์ด")
# CuPy ๋ฒ์
model_cp = LinearRegressionCuPy()
start = time.time()
model_cp.fit(X_cp, y_cp, epochs=100)
cp.cuda.Stream.null.synchronize()
cp_time = time.time() - start
print(f"CuPy ํ์ต ์๊ฐ: {cp_time:.4f}์ด")
print(f"์๋ ํฅ์: {np_time / cp_time:.1f}๋ฐฐ")
import cupy as cp
import time
def convolve2d_naive(image, kernel):
"""์์งํ ๊ตฌํ (๋๋ฆผ)"""
h, w = image.shape
kh, kw = kernel.shape
output = cp.zeros((h - kh + 1, w - kw + 1))
for i in range(output.shape[0]):
for j in range(output.shape[1]):
output[i, j] = cp.sum(
image[i:i+kh, j:j+kw] * kernel
)
return output
def convolve2d_optimized(image, kernel):
"""์ต์ ํ๋ ๊ตฌํ (๋น ๋ฆ)"""
from cupyx.scipy import signal
return signal.convolve2d(image, kernel, mode='valid')
# ํ
์คํธ
image = cp.random.rand(2000, 2000)
kernel = cp.random.rand(5, 5)
# ์ต์ ํ๋ ๋ฒ์ ๋ง ํ
์คํธ (์์งํ ๋ฒ์ ์ ๋๋ฌด ๋๋ฆผ)
start = time.time()
result = convolve2d_optimized(image, kernel)
opt_time = time.time() - start
print(f"์ต์ ํ๋ ์ปจ๋ณผ๋ฃจ์
: {opt_time:.4f}์ด")
# ๋ฐฐ์น ์ฒ๋ฆฌ๋ก ๋ ์ต์ ํ
batch_images = cp.random.rand(100, 2000, 2000)
start = time.time()
batch_results = cp.array([
convolve2d_optimized(img, kernel)
for img in batch_images
])
batch_time = time.time() - start
print(f"๋ฐฐ์น ์ฒ๋ฆฌ (100์ฅ): {batch_time:.4f}์ด")
print(f"์ด๋ฏธ์ง๋น ํ๊ท : {batch_time/100:.4f}์ด")
๐ ์ค๋ฌด์์ ๋ฐ๋ก ์ฐ๋ ์ต์ ํ ์ฒดํฌ๋ฆฌ์คํธ
2. ๋ธ๋ก๋์บ์คํ ํ์ฉ: ๋ถํ์ํ ๋ฐฐ์ด ํ์ฅ ์ ๊ฑฐ
3. ์ ์ ํ dtype ์ ํ: ํ์ํ ์ ๋ฐ๋๋งํผ๋ง ์ฌ์ฉ
4. ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์ ๊ณ ๋ ค: ์ ๊ทผ ํจํด์ ๋ง๋ order ์ ํ
5. ๋ทฐ vs ๋ณต์ฌ: ๋ถํ์ํ ๋ณต์ฌ ์ต์ํ
6. ์ธํ๋ ์ด์ค ์ฐ์ฐ: += ๊ฐ์ ์ฐ์ฐ์ ํ์ฉ
7. einsum ํ์ฉ: ๋ณต์กํ ํ ์ ์ฐ์ฐ ์ต์ ํ
8. out ํ๋ผ๋ฏธํฐ: ๊ฒฐ๊ณผ ๋ฐฐ์ด ์ฌ์ฌ์ฉ
2. ๋ฐ์ดํฐ ์ ์ก ์ต์ํ: GPU์์ ๋ชจ๋ ์ฐ์ฐ ์๋ฃ
3. ๋ฉ๋ชจ๋ฆฌ ํ ํ์ฉ: ๋ฉ๋ชจ๋ฆฌ ํ ๋น/ํด์ ๋น์ฉ ์ ๊ฐ
4. ์คํธ๋ฆผ ํ์ฉ: ๋น๋๊ธฐ ์ฒ๋ฆฌ๋ก ์ค๋ฒ๋ฉ
5. ์ปค๋ ์ตํฉ: ์ฌ๋ฌ ์ฐ์ฐ์ ํ๋๋ก ํฉ์น๊ธฐ
6. ์ ์ ํ ๋ธ๋ก ํฌ๊ธฐ: GPU ์ํคํ ์ฒ์ ๋ง๊ฒ ์กฐ์
7. ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋ชจ๋ํฐ๋ง: OOM ์๋ฌ ๋ฐฉ์ง
8. ํ๋กํ์ผ๋ง: ๋ณ๋ชฉ ์ง์ ์ฐพ๊ธฐ
import numpy as np
import cupy as cp
import time
# ๊ฐ๋จํ ํ์ด๋จธ ๋ฐ์ฝ๋ ์ดํฐ
def timer(func):
def wrapper(*args, **kwargs):
start = time.time()
result = func(*args, **kwargs)
if 'cupy' in str(type(result)):
cp.cuda.Stream.null.synchronize()
end = time.time()
print(f"{func.__name__}: {end - start:.4f}์ด")
return result
return wrapper
@timer
def matrix_multiply_np(size):
a = np.random.rand(size, size)
b = np.random.rand(size, size)
return np.dot(a, b)
@timer
def matrix_multiply_cp(size):
a = cp.random.rand(size, size)
b = cp.random.rand(size, size)
return cp.dot(a, b)
# ํ
์คํธ
for size in [1000, 2000, 5000]:
print(f"\nํฌ๊ธฐ: {size}ร{size}")
matrix_multiply_np(size)
matrix_multiply_cp(size)
# CuPy ํ๋กํ์ผ๋ง
from cupyx.profiler import benchmark
def benchmark_function():
a = cp.random.rand(5000, 5000)
b = cp.random.rand(5000, 5000)
return cp.dot(a, b)
print("\n์์ธ ๋ฒค์น๋งํฌ:")
print(benchmark(benchmark_function, n_repeat=10))
๐ ์ฌ๋ฅ๋ท์์ ๋ฐฐ์ฐ๊ณ ๋๋๊ธฐ
์ฌ๊ธฐ๊น์ง ์ฝ์๋ค๋ฉด ๋๋ ์ด๋ฏธ ํ๋ ฌ ์ฐ์ฐ ์ต์ ํ์ ๊ณ ์๊ฐ ๋์ด๊ฐ๊ณ ์์ด! ๐
์ด๋ฐ ๊ธฐ์ ๋ค์ ํผ์ ๊ณต๋ถํ๊ธฐ์ ์ด๋ ค์ธ ์ ์์ด.
์ฌ๋ฅ๋ท์์๋ ์ด๋ฐ ๊ณ ๊ธ ํ๋ก๊ทธ๋๋ฐ ๊ธฐ์ ์ ๊ฐ๋ฅด์น๊ฑฐ๋ ๋ฐฐ์ธ ์ ์์ด.
์ค๋ฌด ๊ฒฝํ์ด ํ๋ถํ ๊ฐ๋ฐ์๋ค๊ณผ ์ง์ ์ํตํ๋ฉด์ ๋ฐฐ์ฐ๋ฉด ํจ์ฌ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ ์ ์์ง! ๐ช
๋ํ ๋๊ฐ ์ด ๋ถ์ผ์ ๋ฅ์ํ๋ค๋ฉด, ์ฌ๋ฅ๋ท์์ ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ ๊ฐ๋ฅด์ณ์ฃผ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ.
๊ฐ๋ฅด์น๋ฉด์ ๋ ๊น์ด ์ดํดํ๊ฒ ๋๊ฑฐ๋ ! ๐
๐ ๋ ๋์๊ฐ๊ธฐ: ๊ณ ๊ธ ์ฃผ์ ๋ค
๋ฐ์ดํฐ๊ฐ ๋๋ฌด ์ปค์ ํ ๋์ GPU๋ก๋ ๋ถ์กฑํ๋ค๋ฉด?
์ฌ๋ฌ GPU๋ ์ฌ๋ฌ ์๋ฒ๋ฅผ ์ฌ์ฉํ๋ ๋ถ์ฐ ์ปดํจํ
์ ๊ณ ๋ คํด๋ด์ผ ํด! ๐
import cupy as cp
# ์ฌ์ฉ ๊ฐ๋ฅํ GPU ํ์ธ
n_gpus = cp.cuda.runtime.getDeviceCount()
print(f"์ฌ์ฉ ๊ฐ๋ฅํ GPU: {n_gpus}๊ฐ")
# ๊ฐ GPU์ ์์
๋ถ๋ฐฐ
def multi_gpu_computation(data_list):
results = []
for i, data in enumerate(data_list):
gpu_id = i % n_gpus
with cp.cuda.Device(gpu_id):
# ํด๋น GPU์์ ์ฐ์ฐ ์ํ
result = cp.dot(data, data.T)
results.append(result)
return results
# ํ
์คํธ ๋ฐ์ดํฐ
data_list = [cp.random.rand(5000, 5000) for _ in range(4)]
# ๋ค์ค GPU๋ก ์ฒ๋ฆฌ
results = multi_gpu_computation(data_list)
print(f"์ฒ๋ฆฌ ์๋ฃ: {len(results)}๊ฐ ๊ฒฐ๊ณผ")
float16๊ณผ float32๋ฅผ ์์ด ์ฐ๋ฉด ์๋์ ์ ํ๋์ ๊ท ํ์ ๋ง์ถ ์ ์์ด! โ๏ธ
ํนํ ๋ฅ๋ฌ๋์์ ๋ง์ด ์ฌ์ฉ๋๋ ๊ธฐ๋ฒ์ด์ผ.
import cupy as cp
# float16์ผ๋ก ์ฐ์ฐ (๋น ๋ฆ)
a_fp16 = cp.random.rand(10000, 10000).astype(cp.float16)
b_fp16 = cp.random.rand(10000, 10000).astype(cp.float16)
# ์ค์ํ ์ฐ์ฐ์ float32๋ก (์ ํํจ)
result_fp16 = cp.dot(a_fp16, b_fp16)
result_fp32 = result_fp16.astype(cp.float32)
# ์ต์ข
๊ฒฐ๊ณผ๋ ๋์ ์ ๋ฐ๋๋ก
final = cp.sum(result_fp32)
print(f"๊ฒฐ๊ณผ: {final}")
print(f"๋ฉ๋ชจ๋ฆฌ ์ ์ฝ: {a_fp16.nbytes / (10000*10000*4) * 100:.1f}%")
๋๋ถ๋ถ์ ์์๊ฐ 0์ธ ํ๋ ฌ(์คํ์ค ํ๋ ฌ)์ ํน๋ณํ ๋ฐฉ๋ฒ์ผ๋ก ์ ์ฅํ๊ณ ์ฐ์ฐํด์ผ ํด! ๐ธ๏ธ
๋ฉ๋ชจ๋ฆฌ๋ ์ ์ฝ๋๊ณ ์ฐ์ฐ๋ ํจ์ฌ ๋นจ๋ผ์ ธ.
import cupy as cp
from cupyx.scipy import sparse
# ๋ฐ์ง ํ๋ ฌ (๋๋ถ๋ถ 0)
dense = cp.random.rand(10000, 10000)
dense[dense < 0.95] = 0 # 95%๋ฅผ 0์ผ๋ก
print(f"๋ฐ์ง ํ๋ ฌ ํฌ๊ธฐ: {dense.nbytes / 1024**2:.2f} MB")
# ์คํ์ค ํ๋ ฌ๋ก ๋ณํ (CSR ํ์)
sparse_matrix = sparse.csr_matrix(dense)
print(f"์คํ์ค ํ๋ ฌ ํฌ๊ธฐ: {sparse_matrix.data.nbytes / 1024**2:.2f} MB")
# ์คํ์ค ํ๋ ฌ ์ฐ์ฐ
vector = cp.random.rand(10000)
result = sparse_matrix.dot(vector)
print(f"๋ฉ๋ชจ๋ฆฌ ์ ์ฝ: {(1 - sparse_matrix.data.nbytes / dense.nbytes) * 100:.1f}%")
๐ก ์ค์ ํ๊ณผ ์ฃผ์์ฌํญ
2. ๋ถํ์ํ ๋๊ธฐํ: GPU ์ฐ์ฐ์ ๊ธฐ๋ค๋ฆฌ๋ ์ฝ๋
3. ๋ฉ๋ชจ๋ฆฌ ๋์: ์ฌ์ฉํ์ง ์๋ ๋ฐฐ์ด์ ํด์ ํ์ง ์์
4. ํ์ ๋ถ์ผ์น: NumPy์ CuPy ๋ฐฐ์ด์ ์์ด ์ฐ๊ธฐ
5. ๊ณผ๋ํ ์ต์ ํ: ๊ฐ๋ ์ฑ์ ํด์น๋ ์กฐ๊ธฐ ์ต์ ํ
2. ํ๋กํ์ผ๋ง: ์ค์ ๋ณ๋ชฉ ์ง์ ์ฐพ๊ธฐ
3. ์๊ณ ๋ฆฌ์ฆ ๊ฐ์ : O(nยฒ)์ O(n log n)์ผ๋ก
4. ๋ฒกํฐํ: ๋ฃจํ ์ ๊ฑฐ
5. GPU ํ์ฉ: ํฐ ๋ฐ์ดํฐ์๋ง
6. ์ธ๋ถ ์ต์ ํ: ๋ง์ง๋ง ๋จ๊ณ
๐ ์ฑ๋ฅ ๋น๊ต ์์ฝ
์ง๊ธ๊น์ง ๋ฐฐ์ด ๋ด์ฉ์ ์ ๋ฆฌํด๋ณผ๊น? ๐ฏ
์ค์ ์ฑ๋ฅ ํฅ์ ์ ๋๋ฅผ ํ๋ก ์ ๋ฆฌํด๋ดค์ด!
๐ฏ ๊ฒฐ๋ก : ๋น์ ์ ์ฝ๋๋ฅผ ๋ ๊ฐ ๋ฌ์์ฃผ๊ธฐ
์, ์ฌ๊ธฐ๊น์ง ์ ๋ง ๊ธด ์ฌ์ ์ด์์ด! ๐
์ฐ๋ฆฌ๋ NumPy์ ๊ธฐ๋ณธ๋ถํฐ CuPy๋ฅผ ํ์ฉํ GPU ๊ฐ์๊น์ง ๋ค๋ค์ด.
์ด์ ๋๋ ํ๋ ฌ ์ฐ์ฐ์ ์ต์ ํํ๋ ๋ค์ํ ๋ฐฉ๋ฒ์ ์๊ฒ ๋์ง.
ํต์ฌ ํฌ์ธํธ๋ฅผ ๋ค์ ํ ๋ฒ ์ ๋ฆฌํ๋ฉด:
1๏ธโฃ ๋ฒกํฐํ๊ฐ ๊ธฐ๋ณธ: ๋ฃจํ๋ฅผ ์์ ๋ ๊ฒ ์ฒซ ๋ฒ์งธ ๋จ๊ณ
2๏ธโฃ ์ ์ ํ ๋๊ตฌ ์ ํ: ์์ ๋ฐ์ดํฐ๋ NumPy, ํฐ ๋ฐ์ดํฐ๋ CuPy
3๏ธโฃ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ: dtype ์ ํ๊ณผ ๋ถํ์ํ ๋ณต์ฌ ์ ๊ฑฐ
4๏ธโฃ ๋ฐฐ์น ์ฒ๋ฆฌ: ๋ณ๋ ฌ ์ฒ๋ฆฌ์ ํ์ ์ต๋ํ ํ์ฉ
5๏ธโฃ ํ๋กํ์ผ๋ง: ์ถ์ธกํ์ง ๋ง๊ณ ์ธก์ ํ๊ธฐ
๊ฐ์ฅ ์ค์ํ ๊ฑด ์ค์ ๋ก ์จ๋ณด๋ ๊ฒ์ด์ผ! ๐
์ด๋ก ๋ง ์๊ณ ์์ผ๋ฉด ์์ฉ์์ด. ์ง์ ์ฝ๋๋ฅผ ์์ฑํ๊ณ ์คํํด๋ด.
๋งํ๋ ๋ถ๋ถ์ด ์๋ค๋ฉด ์ปค๋ฎค๋ํฐ์ ์ง๋ฌธํ๊ฑฐ๋,
์ฌ๋ฅ๋ท ๊ฐ์ ํ๋ซํผ์์ ์ ๋ฌธ๊ฐ์ ๋์์ ๋ฐ๋ ๊ฒ๋ ์ข์ ๋ฐฉ๋ฒ์ด์ผ! ๐ค
๋์ ์ฝ๋๊ฐ ๋น์ ์๋๋ก ๋ฌ๋ฆฌ๊ธธ ๋ฐ๋ผ! ๐โจ
"์กฐ๊ธฐ ์ต์ ํ๋ ๋ชจ๋ ์ ์ ๊ทผ์์ด๋ค" - ๋๋๋ ํฌ๋์ค
ํ์ง๋ง ์ฌ๋ฐ๋ฅธ ์๊ธฐ์ ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ์ผ๋ก ์ต์ ํํ๋ ๊ฑด ์ ๋ง ์ค์ํด!
์ด ๊ธ์์ ๋ฐฐ์ด ๊ธฐ๋ฒ๋ค์ ํ๋ช ํ๊ฒ ํ์ฉํด์,
๋น ๋ฅด๋ฉด์๋ ์ ์ง๋ณด์ํ๊ธฐ ์ข์ ์ฝ๋๋ฅผ ์์ฑํ๊ธธ ๋ฐ๋ผ! ๐ช
- CuPy ๊ณต์ ๋ฌธ์: docs.cupy.dev
- CUDA ํ๋ก๊ทธ๋๋ฐ ๊ฐ์ด๋
- ์ ํ๋์ ๊ธฐ์ด (MIT OpenCourseWare)
- ๋ณ๋ ฌ ํ๋ก๊ทธ๋๋ฐ ํจํด
๊ทธ๋ฆฌ๊ณ ์ค์ ๊ฒฝํ์ด ๊ฐ์ฅ ์ค์ํ๋ค๋ ๊ฑธ ์์ง ๋ง! ๐ฏ
๐ Happy Optimizing! ๐
๋น์ ์ ์ฝ๋๊ฐ ํญ์ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๊ธธ!
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.