JH'S AI Insight

[Python] 자료구조

AI_JH — Mon, 10 Feb 2025 15:39:03 +0900

자료구조(Data Structure)란?

자료구조는 데이터를 저장하고 관리하는 구조적 방법을 의미합니다. 이를 통해 효율적인 데이터 처리 및 연산 수행이 가능합니다.

1. 선형 자료구조 (Linear Data Structure)

1.1 배열 (Array)

배열은 같은 타입의 데이터를 연속된 메모리 공간에 저장하는 구조입니다.

Index    0   1   2   3   4
Data     10  20  30  40  50

배열의 특징:

탐색: O(1) - 인덱스를 통해 빠르게 접근 가능
삽입/삭제: O(n) - 중간 데이터를 추가/삭제할 때 뒤 데이터를 이동해야 함

1.2 연결 리스트 (Linked List)

연결 리스트는 노드(Node)와 포인터(링크)로 연결된 자료구조입니다.

[HEAD] → [10 | O] → [20 | O] → [30 | NULL]

연결 리스트의 특징:

탐색: O(n) - 처음부터 하나씩 탐색해야 함
삽입/삭제: O(1) - 특정 위치에서 쉽게 추가/삭제 가능

1.3 스택 (Stack)

스택은 후입선출(LIFO, Last In First Out) 구조를 가지는 자료구조입니다.

[TOP] → 30 → 20 → 10

스택의 연산:

push: 데이터를 맨 위에 추가
pop: 맨 위 데이터 제거

1.4 큐 (Queue)

큐는 선입선출(FIFO, First In First Out) 구조를 가지는 자료구조입니다.

[Front] 10 → 20 → 30 [Rear]

큐의 연산:

enqueue: 뒤에서 추가
dequeue: 앞에서 제거

2. 비선형 자료구조 (Non-Linear Data Structure)

2.1 트리 (Tree)

트리는 계층 구조를 가지는 자료구조입니다.

       (10)
      /    \
    (5)    (15)
   /  \    /  \
 (2)  (7) (12) (20)

이진 탐색 트리 (BST)의 특징:

왼쪽 자식 노드 < 부모 < 오른쪽 자식 노드
탐색 속도: O(log n)

2.2 그래프 (Graph)

그래프는 노드(Vertex)와 간선(Edge)으로 이루어진 자료구조입니다.

A - B - C
|    |
D - E

그래프 탐색 알고리즘:

DFS (깊이 우선 탐색)
BFS (너비 우선 탐색)

자료구조 선택 기준

자료구조	삽입	삭제	탐색
배열(Array)	O(1)	O(n)	O(1)
연결 리스트(Linked List)	O(1)	O(1)	O(n)
스택(Stack)	O(1)	O(1)	O(n)
큐(Queue)	O(1)	O(1)	O(n)
트리(Tree)	O(log n)	O(log n)	O(log n)

[Python] Numpy 소개

AI_JH — Sun, 9 Feb 2025 21:59:16 +0900

NumPy 개요 및 사용법

1. NumPy란?

NumPy(Numerical Python)는 Python에서 수학적 연산과 다차원 배열 연산을 수행하는 대표적인 라이브러리입니다.

빠르고 효율적인 다차원 배열(ndarray) 연산
C 기반 구현으로 높은 성능 제공
벡터화 연산을 통해 반복문 최소화
선형 대수, 난수 생성, 푸리에 변환 등 다양한 기능 포함
Pandas, SciPy, PyTorch 등의 여러 라이브러리의 기반 역할

2. NumPy 배열(NDArray)

NumPy의 핵심 데이터 구조는 ndarray (N-dimensional array) 입니다.

(1) 배열 생성

import numpy as np
arr = np.array([1, 2, 3, 4, 5])
print(arr)
print(type(arr))

(2) 다차원 배열

arr2d = np.array([[1, 2, 3], [4, 5, 6]])
print(arr2d)
print(arr2d.shape)
print(arr2d.ndim)
print(arr2d.dtype)

3. NumPy 주요 기능

(1) 배열 생성 함수

zeros = np.zeros((3, 3))
ones = np.ones((2, 4))
full = np.full((3, 3), 7)
identity = np.eye(4)
print(zeros)
print(ones)
print(full)
print(identity)

(2) 난수 생성

rand_uniform = np.random.rand(3, 3)
rand_normal = np.random.randn(3, 3)
rand_int = np.random.randint(0, 10, (3, 3))
np.random.seed(42)
print(rand_uniform)
print(rand_normal)
print(rand_int)

(3) 배열 연산

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b)
print(a - b)
print(a * b)
print(a / b)

(4) 행렬 연산

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C = np.dot(A, B)
print(C)
print(A.T)
A_inv = np.linalg.inv(A)
det = np.linalg.det(A)
print(A_inv)
print(det)

(5) 배열 인덱싱 및 슬라이싱

arr = np.array([[1, 2, 3], [4, 5, 6]])
print(arr[0, 1])
print(arr[0, :])
print(arr[:, 0:2])

(6) 배열 조건 처리

arr = np.array([1, 2, 3, 4, 5])
print(arr[arr > 2])
arr[arr > 2] = 10
print(arr)

4. NumPy vs Python List 성능 비교

import time
size = 10**6

# Python 리스트 연산 속도 비교
start = time.time()
a_list = list(range(size))
b_list = list(range(size))
c_list = [a + b for a, b in zip(a_list, b_list)]
print("Python 리스트 연산 시간:", time.time() - start)

# NumPy 배열 연산 속도 비교
start = time.time()
a_array = np.arange(size)
b_array = np.arange(size)
c_array = a_array + b_array
print("NumPy 배열 연산 시간:", time.time() - start)

5. NumPy 요약

기능	설명
배열 생성	np.array(), np.zeros(), np.ones(), np.eye()
난수 생성	np.random.rand(), np.random.randint()
배열 연산	+, -, *, /, np.dot()
선형 대수	np.linalg.inv(), np.linalg.det(), A.T
인덱싱	arr[i, j], arr[:, i], Fancy Indexing
조건 필터링	arr[arr > 2]

[Python] PyTorch 소개

AI_JH — Sun, 9 Feb 2025 21:53:50 +0900

PyTorch 소개

1. PyTorch란?

PyTorch는 Facebook AI Research(FAIR)에서 개발한 Python 기반 오픈소스 딥러닝 프레임워크입니다.

NumPy와 유사한 텐서 연산 지원
GPU 가속(CUDA)로 빠른 연산 가능
동적 연산 그래프(Dynamic Computation Graph) 사용
사용이 직관적이고 디버깅이 쉬움
딥러닝, 자연어 처리(NLP), 컴퓨터 비전(CV) 등에 폭넓게 활용됨

2. PyTorch 주요 개념

(1) 텐서(Tensor)

PyTorch에서 가장 기본적인 자료형은 Tensor입니다.

import torch

a = torch.tensor([1, 2, 3])
b = torch.tensor([[1, 2], [3, 4]])
c = torch.randn(2, 3, 4)
print(c.shape)

(2) NumPy 변환

import numpy as np

t = torch.tensor([1, 2, 3])
n = t.numpy()
print(n, type(n))

n = np.array([4, 5, 6])
t = torch.from_numpy(n)
print(t, type(t))

(3) GPU 연산

device = 'cuda' if torch.cuda.is_available() else 'cpu'
x = torch.randn(3, 3).to(device)
print(x.device)

(4) 텐서 연산

x = torch.tensor([1, 2, 3])
y = torch.tensor([4, 5, 6])
print(x + y)

3. PyTorch 모델 만들기

(1) torch.nn을 이용한 모델 정의

import torch.nn as nn

class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc = nn.Linear(10, 1)
    
    def forward(self, x):
        return self.fc(x)

model = MyModel()
print(model)

(2) 손실 함수 및 옵티마이저

import torch.optim as optim

loss_fn = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=0.01)

(3) 학습 과정

for epoch in range(10):
    optimizer.zero_grad()
    x = torch.randn(5, 10)
    y = torch.randn(5, 1)
    pred = model(x)
    loss = loss_fn(pred, y)
    loss.backward()
    optimizer.step()
    print(f"Epoch {epoch+1}, Loss: {loss.item()}")

4. 데이터 로딩 (torch.utils.data)

from torch.utils.data import Dataset, DataLoader

class MyDataset(Dataset):
    def __init__(self):
        self.data = torch.randn(100, 10)
        self.labels = torch.randint(0, 2, (100,))
    
    def __len__(self):
        return len(self.data)
    
    def __getitem__(self, idx):
        return self.data[idx], self.labels[idx]

dataset = MyDataset()
dataloader = DataLoader(dataset, batch_size=8, shuffle=True)

5. PyTorch 주요 기능 요약

기능	설명
텐서 연산	torch.tensor(), +, -, * 등 다양한 연산
GPU 연산	.to('cuda')를 이용해 GPU에서 연산 가능
신경망 정의	nn.Module을 상속받아 모델 생성
손실 함수	nn.MSELoss(), nn.CrossEntropyLoss() 등 다양한 손실 함수
옵티마이저	optim.SGD(), optim.Adam() 등 최적화 알고리즘
역전파 학습	zero_grad(), loss.backward(), step() 사용
데이터 로딩	Dataset, DataLoader를 활용하여 데이터 배치 로딩

[Python] Einops

AI_JH — Sun, 9 Feb 2025 21:46:07 +0900

einops 개념 및 사용법

einops는 배열 및 텐서를 직관적으로 변환할 수 있도록 설계된 Python 라이브러리입니다.

간결한 문자열 기반 표기법을 통해 reshape, transpose, reduce 등의 연산을 쉽게 수행할 수 있습니다.

지원 프레임워크: numpy, torch, tensorflow, jax

1. einops가 필요한 이유

기존의 numpy, torch, tensorflow 등의 텐서 조작(reshape, permute, transpose)은 복잡하고 가독성이 떨어질 수 있습니다.

import torch
x = torch.randn(16, 3, 64, 64)  # (batch, channel, height, width)
x = x.permute(0, 2, 3, 1)  # (batch, height, width, channel)

einops를 사용하면 다음처럼 간결하게 표현할 수 있습니다.

from einops import rearrange
x = rearrange(x, 'b c h w -> b h w c')

2. einops의 주요 기능

기능	설명	함수
재배열 (Rearrange)	텐서의 차원 순서 변경	rearrange
축소 (Reduce)	특정 차원을 줄이면서 연산 수행	reduce
재조합 (Repeat)	특정 차원을 복제하여 확장	repeat

3. 주요 연산 예제

rearrange: 텐서 변형 (reshape, transpose)

from einops import rearrange
import numpy as np

x = np.random.random((2, 3, 4))
y = rearrange(x, 'b c h -> b h c')
print(y.shape)  # (2, 4, 3)

reduce: 특정 차원 축소

from einops import reduce
x = np.random.random((2, 3, 4))
y = reduce(x, 'b c h -> b h', 'mean')
print(y.shape)  # (2, 4)

repeat: 차원 확장 (broadcasting)

from einops import repeat
x = np.random.random((2, 3))
y = repeat(x, 'b f -> b f 4')
print(y.shape)  # (2, 3, 4)

4. 다양한 예제

CNN: NCHW ↔ NHWC 변환

x = np.random.random((16, 3, 64, 64))
y = rearrange(x, 'b c h w -> b h w c')
print(y.shape)  # (16, 64, 64, 3)

ViT (Vision Transformer) 패치 분할

img = np.random.random((1, 3, 256, 256))
patches = rearrange(img, 'b c (h p1) (w p2) -> b (h w) (p1 p2 c)', p1=16, p2=16)
print(patches.shape)  # (1, 256, 768)

NLP: Transformer Multi-Head Attention에서 heads 추가

q = np.random.random((32, 128))
q_heads = rearrange(q, 'b (h d) -> b h d', h=8)
print(q_heads.shape)  # (32, 8, 16)

5. einops vs 기존 방법 비교

연산	기존 방법	einops
Reshape	x.view()	rearrange(x, 'b c h w -> b h w c')
Transpose	x.permute()	rearrange(x, 'b c h w -> b h w c')
Reduce (mean)	x.mean(dim=1)	reduce(x, 'b c h -> b h', 'mean')
Expand (repeat)	x.repeat()	repeat(x, 'b f -> b f 4')

6. einops의 장점

✅ 가독성 증가: 직관적인 문자열 표현
✅ 프레임워크 독립적: numpy, torch, tensorflow, jax 등에서 사용 가능
✅ 코드 간결화: reshape, permute, transpose 등을 하나의 문법으로 처리
✅ 배치 연산 지원: 다차원 연산을 쉽게 수행

7. einops 요약

기능	함수	설명
재배열 (Rearrange)	rearrange(x, 'b c h w -> b h w c')	차원 순서 변경
축소 (Reduce)	reduce(x, 'b c h -> b h', 'mean')	특정 차원을 평균/합산으로 축소
확장 (Repeat)	repeat(x, 'b f -> b f 4')	특정 차원을 반복하여 확장

[Python] Einsum

AI_JH — Sun, 9 Feb 2025 21:16:46 +0900

einsum 개념 및 사용법

numpy.einsum()은 아인슈타인 합(아인슈타인 표기법)을 이용하여 다차원 배열의 연산을 간결하게 수행할 수 있는 함수입니다.

1. 기본 개념: 아인슈타인 합 표기법

아인슈타인 합 표기법은 반복되는 인덱스를 축소(합산)하는 방법입니다. 예를 들어, 두 벡터 a, b의 내적(dot product)은 다음과 같이 표현됩니다.

$$ c = \sum_{i} a_{i} b_{i} $$

이 수식을 einsum으로 표현하면:


import numpy as np

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])

c = np.einsum('i,i->', a, b)
print(c)

결과: $ 32 $ (벡터 내적 결과)

2. einsum의 주요 연산 예제

(1) 행렬 곱셈

행렬 곱셈(행렬 A와 B의 곱)도 einsum으로 쉽게 구현할 수 있습니다.

$$ C_{ij} = \sum_{k} A_{ik} B_{kj} $$


A = np.array([[1, 2], [3, 4]])  # (2x2)
B = np.array([[5, 6], [7, 8]])  # (2x2)

C = np.einsum('ik,kj->ij', A, B)
print(C)

출력 결과:


[[19 22]
 [43 50]]

이는 일반적인 행렬 곱셈 np.dot(A, B) 또는 A @ B와 동일합니다.

(2) 벡터 외적 (Outer Product)

외적(outer product)은 다음과 같이 einsum을 활용할 수 있습니다.


A = np.array([1, 2, 3])
B = np.array([4, 5, 6])

outer_product = np.einsum('i,j->ij', A, B)
print(outer_product)

출력 결과:


[[ 4  5  6]
 [ 8 10 12]
 [12 15 18]]

'i,j->ij'는 $ i $와 $ j $를 곱하여 $ (i, j) $ 형태의 2D 배열을 생성.

(3) 행렬 전치 (Transpose)


A = np.array([[1, 2, 3], [4, 5, 6]])
A_T = np.einsum('ij->ji', A)
print(A_T)

출력 결과:


[[1 4]
 [2 5]
 [3 6]]

이는 np.transpose(A) 또는 A.T와 동일합니다.

(4) 행렬 대각합 (Trace)


A = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
trace = np.einsum('ii->', A)
print(trace)  # 1 + 5 + 9 = 15

출력 결과:

이는 np.trace(A)와 동일한 결과입니다.

(5) 배치 행렬 곱셈 (Batch Matrix Multiplication)

3차원 이상의 행렬 곱셈도 einsum을 사용하면 쉽게 구현할 수 있습니다.


A = np.random.rand(10, 3, 4)  # 배치 크기 10, 3x4 행렬
B = np.random.rand(10, 4, 5)  # 배치 크기 10, 4x5 행렬

C = np.einsum('ijk,ikl->ijl', A, B)
print(C.shape)  # (10, 3, 5)

위 코드는 np.matmul(A, B) 또는 A @ B와 동일한 역할을 합니다.

3. einsum의 장점

가독성: einsum은 긴 루프 없이 수식을 직관적으로 표현할 수 있음.
성능 최적화: einsum은 numpy 내부에서 최적화되어 빠르게 동작하고, 불필요한 메모리 할당을 줄일 수 있음.
다양한 연산 지원: 내적, 외적, 전치, 대각합, 배치 연산 등 여러 수학적 연산을 하나의 함수로 수행 가능.

4. einsum 사용 팁

numpy.einsum_path()를 사용하면 연산 최적화 경로를 확인할 수 있음.


optimal_path = np.einsum_path('ik,kj->ij', A, B, optimize=True)
print(optimal_path)

최적화된 einsum 실행:


C = np.einsum('ik,kj->ij', A, B, optimize=True)

결론

einsum은 행렬 연산을 효율적으로 수행하는 강력한 도구.
내적, 외적, 전치, 대각합 등 다양한 연산을 하나의 함수로 표현 가능.
코드 가독성을 높이고 최적화할 때 유용.

다양한 차원의 배열 연산을 직관적이고 효율적으로 구현하려면 einsum을 적극 활용하는 것이 좋습니다!