Guide Keras에서 PyTorch로 전환하기

from tensorflow import keras
from tensorflow.keras import layers

# 모델 정의
model = keras.Sequential([
    layers.Dense(128, activation='relu', 
                 input_shape=(784,)),
    layers.Dropout(0.2),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.2),
    layers.Dense(10, activation='softmax')
])

# 컴파일
model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

# 학습
model.fit(x_train, y_train, 
          epochs=10, 
          batch_size=32,
          validation_split=0.2)

import torch
import torch.nn as nn
import torch.optim as optim

# 모델 정의
class MLP(nn.Module):
    def __init__(self):
        super(MLP, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.dropout1 = nn.Dropout(0.2)
        self.fc2 = nn.Linear(128, 64)
        self.dropout2 = nn.Dropout(0.2)
        self.fc3 = nn.Linear(64, 10)
    
    def forward(self, x):
        x = torch.relu(self.fc1(x))
        x = self.dropout1(x)
        x = torch.relu(self.fc2(x))
        x = self.dropout2(x)
        x = self.fc3(x)
        return x

model = MLP()
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 학습 루프는 직접 작성 (다음 섹션 참조)

from tensorflow.keras import Input, Model
from tensorflow.keras.layers import (
    Dense, Concatenate
)

# 다중 입력
input1 = Input(shape=(10,))
input2 = Input(shape=(20,))

# 첫 번째 브랜치
x1 = Dense(64, activation='relu')(input1)
x1 = Dense(32, activation='relu')(x1)

# 두 번째 브랜치
x2 = Dense(64, activation='relu')(input2)
x2 = Dense(32, activation='relu')(x2)

# 병합
merged = Concatenate()([x1, x2])
output = Dense(1, activation='sigmoid')(merged)

# 모델 생성
model = Model(
    inputs=[input1, input2], 
    outputs=output
)

model.compile(optimizer='adam', 
              loss='binary_crossentropy')

import torch.nn as nn

class MultiInputModel(nn.Module):
    def __init__(self):
        super().__init__()
        # 첫 번째 브랜치
        self.branch1 = nn.Sequential(
            nn.Linear(10, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU()
        )
        
        # 두 번째 브랜치
        self.branch2 = nn.Sequential(
            nn.Linear(20, 64),
            nn.ReLU(),
            nn.Linear(64, 32),
            nn.ReLU()
        )
        
        # 출력 레이어
        self.output = nn.Linear(64, 1)
    
    def forward(self, input1, input2):
        x1 = self.branch1(input1)
        x2 = self.branch2(input2)
        merged = torch.cat([x1, x2], dim=1)
        return torch.sigmoid(self.output(merged))

model = MultiInputModel()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters())

# 한 줄로 끝!
history = model.fit(
    x_train, y_train,
    batch_size=32,
    epochs=10,
    validation_data=(x_val, y_val),
    callbacks=[
        keras.callbacks.EarlyStopping(
            patience=3
        ),
        keras.callbacks.ModelCheckpoint(
            'best_model.h5'
        )
    ]
)

# 평가
test_loss, test_acc = model.evaluate(
    x_test, y_test
)

# 예측
predictions = model.predict(x_test)

from torch.utils.data import DataLoader, TensorDataset

# 데이터로더 준비
train_dataset = TensorDataset(x_train, y_train)
train_loader = DataLoader(
    train_dataset, 
    batch_size=32, 
    shuffle=True
)

# 학습 루프
model.train()
for epoch in range(10):
    running_loss = 0.0
    for inputs, labels in train_loader:
        # 그래디언트 초기화
        optimizer.zero_grad()
        
        # Forward pass
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        
        # Backward pass
        loss.backward()
        
        # 파라미터 업데이트
        optimizer.step()
        
        running_loss += loss.item()
    
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(train_loader):.4f}')

# 평가
model.eval()
with torch.no_grad():
    test_outputs = model(x_test)
    test_loss = criterion(test_outputs, y_test)

# 예측
predictions = model(x_test)

from tensorflow.keras.preprocessing.image import (
    ImageDataGenerator
)

# 데이터 증강
datagen = ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    rescale=1./255
)

# 디렉토리에서 데이터 로드
train_generator = datagen.flow_from_directory(
    'data/train',
    target_size=(224, 224),
    batch_size=32,
    class_mode='categorical'
)

# 학습
model.fit(
    train_generator,
    epochs=10,
    steps_per_epoch=100
)

from torch.utils.data import Dataset, DataLoader
from torchvision import transforms
from PIL import Image
import os

# 커스텀 데이터셋
class CustomDataset(Dataset):
    def __init__(self, root_dir, transform=None):
        self.root_dir = root_dir
        self.transform = transform
        self.images = os.listdir(root_dir)
    
    def __len__(self):
        return len(self.images)
    
    def __getitem__(self, idx):
        img_path = os.path.join(
            self.root_dir, 
            self.images[idx]
        )
        image = Image.open(img_path)
        label = ...  # 레이블 로직
        
        if self.transform:
            image = self.transform(image)
        
        return image, label

# 데이터 증강
transform = transforms.Compose([
    transforms.RandomRotation(20),
    transforms.RandomHorizontalFlip(),
    transforms.Resize((224, 224)),
    transforms.ToTensor(),
    transforms.Normalize(
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225]
    )
])

dataset = CustomDataset(
    'data/train', 
    transform=transform
)
train_loader = DataLoader(
    dataset, 
    batch_size=32, 
    shuffle=True,
    num_workers=4
)

from tensorflow.keras.datasets import mnist

# 데이터 로드
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 전처리
x_train = x_train.reshape(-1, 784) / 255.0
x_test = x_test.reshape(-1, 784) / 255.0

# 바로 학습
model.fit(x_train, y_train, epochs=5)

from torchvision import datasets, transforms
from torch.utils.data import DataLoader

# 데이터 변환 정의
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])

# 데이터셋 로드
train_dataset = datasets.MNIST(
    'data', 
    train=True, 
    download=True,
    transform=transform
)

# 데이터로더 생성
train_loader = DataLoader(
    train_dataset, 
    batch_size=64, 
    shuffle=True
)

# 학습 루프에서 사용
for images, labels in train_loader:
    # 학습 코드...

from tensorflow.keras import layers, models

model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', 
                  input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    
    layers.Conv2D(64, (3, 3), activation='relu'),
    
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dropout(0.5),
    layers.Dense(10, activation='softmax')
])

model.compile(
    optimizer='adam',
    loss='sparse_categorical_crossentropy',
    metrics=['accuracy']
)

model.summary()

import torch.nn as nn
import torch.nn.functional as F

class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, 3)
        self.pool = nn.MaxPool2d(2, 2)
        
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.conv3 = nn.Conv2d(64, 64, 3)
        
        self.fc1 = nn.Linear(64 * 1 * 1, 64)
        self.dropout = nn.Dropout(0.5)
        self.fc2 = nn.Linear(64, 10)
    
    def forward(self, x):
        x = self.pool(F.relu(self.conv1(x)))
        x = self.pool(F.relu(self.conv2(x)))
        x = F.relu(self.conv3(x))
        
        x = x.view(-1, 64 * 1 * 1)  # Flatten
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.fc2(x)
        return x

model = CNN()

# 모델 요약 (torchsummary 사용)
from torchsummary import summary
summary(model, (1, 28, 28))

# 전체 모델 저장 (아키텍처 + 가중치)
model.save('my_model.h5')
model.save('my_model.keras')  # 새로운 형식

# 가중치만 저장
model.save_weights('weights.h5')

# 모델 불러오기
from tensorflow.keras.models import load_model
loaded_model = load_model('my_model.h5')

# 가중치만 불러오기
model.load_weights('weights.h5')

# TensorFlow SavedModel 형식
model.save('saved_model/')
loaded = tf.keras.models.load_model('saved_model/')

# 가중치만 저장 (일반적인 방법)
torch.save(model.state_dict(), 'model_weights.pth')

# 전체 모델 저장 (비추천)
torch.save(model, 'entire_model.pth')

# 체크포인트 저장 (최선의 방법)
torch.save({
    'epoch': epoch,
    'model_state_dict': model.state_dict(),
    'optimizer_state_dict': optimizer.state_dict(),
    'loss': loss,
}, 'checkpoint.pth')

# 가중치 불러오기
model = CNN()  # 모델 클래스 정의 필요!
model.load_state_dict(
    torch.load('model_weights.pth')
)
model.eval()

# 체크포인트 불러오기
checkpoint = torch.load('checkpoint.pth')
model.load_state_dict(checkpoint['model_state_dict'])
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
epoch = checkpoint['epoch']
loss = checkpoint['loss']

import tensorflow as tf

# GPU 확인
print("GPU 사용 가능:", tf.config.list_physical_devices('GPU'))

# 자동으로 GPU 사용
# 별도 코드 불필요!

# 특정 GPU 선택
gpus = tf.config.list_physical_devices('GPU')
if gpus:
    tf.config.set_visible_devices(gpus[0], 'GPU')

# 메모리 증가 허용
for gpu in gpus:
    tf.config.experimental.set_memory_growth(gpu, True)

import torch

# GPU 확인
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print(f"사용 장치: {device}")

# 모델을 GPU로 이동
model = model.to(device)

# 학습 루프에서 데이터도 GPU로 이동
for inputs, labels in train_loader:
    inputs = inputs.to(device)
    labels = labels.to(device)
    
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    # ...

# 특정 GPU 선택
device = torch.device('cuda:0')  # 첫 번째 GPU
model.to(device)

# 다중 GPU
if torch.cuda.device_count() > 1:
    model = nn.DataParallel(model)
model.to(device)

# 모델 요약
model.summary()

# 레이어별 출력 확인
from tensorflow.keras import Model

layer_outputs = [layer.output for layer in model.layers]
activation_model = Model(
    inputs=model.input, 
    outputs=layer_outputs
)
activations = activation_model.predict(x_test[0:1])

# 가중치 확인
for layer in model.layers:
    weights = layer.get_weights()
    print(f"{layer.name}: {len(weights)} 가중치")

# 그래디언트 확인 (복잡함)
import tensorflow as tf
with tf.GradientTape() as tape:
    predictions = model(x_train[:1])
    loss = loss_fn(y_train[:1], predictions)
grads = tape.gradient(loss, model.trainable_weights)

# 모델 요약 (torchsummary 사용)
from torchsummary import summary
summary(model, input_size=(1, 28, 28))

# 중간 레이어 출력 확인 (Hook 사용)
activation = {}
def get_activation(name):
    def hook(model, input, output):
        activation[name] = output.detach()
    return hook

model.fc1.register_forward_hook(get_activation('fc1'))
output = model(x)
print(activation['fc1'])

# 가중치 확인
for name, param in model.named_parameters():
    print(f"{name}: {param.shape}")

# 그래디언트 확인 (매우 쉬움!)
output = model(x)
loss = criterion(output, y)
loss.backward()

for name, param in model.named_parameters():
    if param.grad is not None:
        print(f"{name} gradient: {param.grad.norm()}")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers

# 1. 데이터 로드
(x_train, y_train), (x_test, y_test) = keras.datasets.cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0

# 2. 모델 정의
model = keras.Sequential([
    layers.Conv2D(32, 3, activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D(),
    layers.Conv2D(64, 3, activation='relu'),
    layers.MaxPooling2D(),
    layers.Conv2D(64, 3, activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10)
])

# 3. 컴파일
model.compile(
    optimizer='adam',
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    metrics=['accuracy']
)

# 4. 학습
history = model.fit(
    x_train, y_train,
    epochs=10,
    validation_data=(x_test, y_test)
)

# 5. 평가
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Test accuracy: {test_acc}')

# 6. 예측
predictions = model.predict(x_test[:5])

# 총 코드 줄 수: ~30줄

import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# 1. 데이터 로드
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

trainset = datasets.CIFAR10('data', train=True, download=True, transform=transform)
testset = datasets.CIFAR10('data', train=False, download=True, transform=transform)

trainloader = DataLoader(trainset, batch_size=64, shuffle=True)
testloader = DataLoader(testset, batch_size=64, shuffle=False)

# 2. 모델 정의
class CNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(3, 32, 3)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv2 = nn.Conv2d(32, 64, 3)
        self.conv3 = nn.Conv2d(64, 64, 3)
        self.fc1 = nn.Linear(64 * 4 * 4, 64)
        self.fc2 = nn.Linear(64, 10)
    
    def forward(self, x):
        x = self.pool(torch.relu(self.conv1(x)))
        x = self.pool(torch.relu(self.conv2(x)))
        x = torch.relu(self.conv3(x))
        x = x.view(-1, 64 * 4 * 4)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
model = CNN().to(device)

# 3. 손실함수 & 옵티마이저
criterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters())

# 4. 학습
for epoch in range(10):
    model.train()
    running_loss = 0.0
    for inputs, labels in trainloader:
        inputs, labels = inputs.to(device), labels.to(device)
        
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, labels)
        loss.backward()
        optimizer.step()
        
        running_loss += loss.item()
    
    print(f'Epoch {epoch+1}, Loss: {running_loss/len(trainloader):.3f}')

# 5. 평가
model.eval()
correct = 0
total = 0
with torch.no_grad():
    for inputs, labels in testloader:
        inputs, labels = inputs.to(device), labels.to(device)
        outputs = model(inputs)
        _, predicted = torch.max(outputs.data, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f'Test accuracy: {100 * correct / total}%')

# 총 코드 줄 수: ~70줄