torch.tensor([1, 2, 3]) | 리스트에서 텐서 생성 |
torch.zeros(3, 4) | 0 텐서 |
torch.ones(2, 3) | 1 텐서 |
torch.empty(2, 2) | 초기화되지 않은 텐서 |
torch.rand(3, 4) | 균등 랜덤 [0, 1) |
torch.randn(3, 4) | 정규 랜덤 |
torch.arange(0, 10, 2) | 범위 텐서 |
torch.linspace(0, 1, 5) | 균등 간격 |
torch.eye(4) | 단위 행렬 |
t.shape, t.size() | 텐서 형태 |
t.dtype | 데이터 타입 |
t.device | 디바이스 (CPU/GPU) |
t.requires_grad | 그래디언트 추적 |
t.numel() | 요소 수 |
t.dim() | 차원 수 |
t.float(), t.double(), t.int() | 타입 변환 |
t.to(torch.float32) | dtype으로 변환 |
t.cuda() | GPU로 이동 |
t.cpu() | CPU로 이동 |
t.to("cuda:0") | 특정 GPU로 이동 |
torch.cuda.is_available() | GPU 사용 가능 확인 |
t.view(3, 4) | 형태 변환 (연속 필요) |
t.reshape(3, 4) | 형태 변환 (유연) |
t.flatten() | 1D로 평탄화 |
t.squeeze() | 크기 1 차원 제거 |
t.unsqueeze(0) | 인덱스에 차원 추가 |
t.transpose(0, 1) | 차원 교환 |
t.permute(2, 0, 1) | 차원 재정렬 |
torch.add(a, b), a + b | 덧셈 |
torch.mul(a, b), a * b | 요소별 곱셈 |
torch.matmul(a, b), a @ b | 행렬 곱셈 |
torch.mm(a, b) | 2D 행렬 곱셈 |
torch.bmm(a, b) | 배치 행렬 곱셈 |
torch.pow(t, 2), t ** 2 | 거듭제곱 |
torch.sqrt(t) | 제곱근 |
torch.exp(t), torch.log(t) | 지수/로그 |
t.sum(), t.sum(dim=0) | 합계 |
t.mean(), t.mean(dim=0) | 평균 |
t.std(), t.var() | 표준편차/분산 |
t.max(), t.min() | 최대/최소 |
t.argmax(), t.argmin() | 최대/최소 인덱스 |
t.prod() | 곱 |
torch.cat([a, b], dim=0) | 연결 |
torch.stack([a, b], dim=0) | 스택 (새 차원) |
torch.split(t, 2, dim=0) | 청크로 분할 |
torch.chunk(t, 3, dim=0) | n개 청크로 분할 |
x = torch.tensor([1.0], requires_grad=True) | 그래디언트 추적 활성화 |
y.backward() | 그래디언트 계산 |
x.grad | 그래디언트 접근 |
x.grad.zero_() | 그래디언트 초기화 |
with torch.no_grad(): | 그래디언트 비활성화 |
x.detach() | 그래프에서 분리 |
x.requires_grad_(True) | 제자리 그래디언트 활성화 |
nn.Linear(in_features, out_features) | 완전 연결 레이어 |
nn.Conv2d(in_ch, out_ch, kernel) | 2D 합성곱 |
nn.ConvTranspose2d(...) | 전치 합성곱 |
nn.MaxPool2d(kernel_size) | 최대 풀링 |
nn.AvgPool2d(kernel_size) | 평균 풀링 |
nn.BatchNorm2d(num_features) | 배치 정규화 |
nn.LayerNorm(normalized_shape) | 레이어 정규화 |
nn.Dropout(p=0.5) | 드롭아웃 |
nn.Embedding(num_embed, embed_dim) | 임베딩 레이어 |
nn.LSTM(input_size, hidden_size) | LSTM 레이어 |
nn.GRU(input_size, hidden_size) | GRU 레이어 |
nn.ReLU() | ReLU 활성화 |
nn.LeakyReLU(0.1) | Leaky ReLU |
nn.Sigmoid() | 시그모이드 |
nn.Tanh() | Tanh |
nn.Softmax(dim=1) | 소프트맥스 |
nn.GELU() | GELU 활성화 |
nn.MSELoss() | 평균 제곱 오차 |
nn.CrossEntropyLoss() | 교차 엔트로피 |
nn.BCELoss() | 이진 교차 엔트로피 |
nn.BCEWithLogitsLoss() | 시그모이드 포함 BCE |
nn.L1Loss() | L1/MAE 손실 |
nn.NLLLoss() | 음의 로그 우도 |
class Model(nn.Module): | 커스텀 모델 정의 |
def __init__(self): super().__init__() | 모델 초기화 |
def forward(self, x): return self.layer(x) | 순전파 |
nn.Sequential(nn.Linear(10, 5), nn.ReLU()) | 순차 모델 |
model.parameters() | 모든 파라미터 가져오기 |
model.named_parameters() | 이름 포함 파라미터 |
model.train() | 학습 모드 설정 |
model.eval() | 평가 모드 설정 |
model.to(device) | 디바이스로 모델 이동 |
torch.optim.SGD(params, lr=0.01) | SGD 옵티마이저 |
torch.optim.Adam(params, lr=0.001) | Adam 옵티마이저 |
torch.optim.AdamW(params, lr=0.001) | AdamW 옵티마이저 |
torch.optim.RMSprop(params, lr=0.01) | RMSprop 옵티마이저 |
optimizer.zero_grad() | 그래디언트 초기화 |
optimizer.step() | 가중치 업데이트 |
optim.lr_scheduler.StepLR(opt, step_size=10) | 스텝 LR 감소 |
optim.lr_scheduler.ExponentialLR(opt, gamma=0.9) | 지수 감소 |
optim.lr_scheduler.CosineAnnealingLR(opt, T_max) | 코사인 어닐링 |
scheduler.step() | 학습률 업데이트 |
output = model(input) | 순전파 |
loss = criterion(output, target) | 손실 계산 |
loss.backward() | 역전파 |
optimizer.step() | 파라미터 업데이트 |
torch.nn.utils.clip_grad_norm_(params, max_norm) | 그래디언트 클리핑 |
DataLoader(dataset, batch_size=32, shuffle=True) | DataLoader 생성 |
for batch in dataloader: | 배치 반복 |
num_workers=4 | 병렬 데이터 로딩 |
pin_memory=True | GPU용 메모리 고정 |
drop_last=True | 불완전한 배치 버리기 |
class MyDataset(Dataset): | 커스텀 데이터셋 |
def __len__(self): | 데이터셋 길이 반환 |
def __getitem__(self, idx): | 단일 샘플 반환 |
TensorDataset(x_tensor, y_tensor) | 텐서에서 데이터셋 |
torch.save(model.state_dict(), "model.pt") | 모델 가중치 저장 |
model.load_state_dict(torch.load("model.pt")) | 모델 가중치 불러오기 |
torch.save(model, "full_model.pt") | 전체 모델 저장 |
torch.save({"model": m.state_dict(), "opt": o.state_dict()}, "ckpt.pt") | 체크포인트 저장 |