파이토치 CNN 분석

Convolutional Neural Networks (CNNs)는 일반적으로 이미지 처리에 많이 사용되지만, 1D Convolutional Networks (Conv1D)는 시계열 데이터나 자연어 처리에도 효과적입니다. 이 경우, 고객의 행동 시퀀스를 1D 시계열 데이터로 간주하고, Conv1D 모델을 사용해 펀드 상품 구매 여부를 예측하는 코드를 작성할 수 있습니다.

### 예제 코드
아래 예제에서는 고객의 페이지 방문 시퀀스를 Conv1D 모델에 입력으로 사용하여, 펀드 상품 구매 여부를 예측하는 파이토치(Pytorch) 모델을 구축합니다.

### 1. 데이터 준비
우선, 페이지 이름을 숫자로 인코딩하고, 이를 시퀀스 데이터로 변환합니다.

```python
import torch
import torch.nn as nn
import torch.optim as optim
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import LabelEncoder
from keras.preprocessing.sequence import pad_sequences

# 가상 로그 데이터 (예시)
data = {
    'user_id': [1, 1, 1, 1, 2, 2, 3, 3, 3, 3],
    'page': ['home', 'product', 'home', 'checkout', 'home', 'product', 'home', 'product', 'cart', 'checkout'],
    'label': [1, 1, 1, 1, 0, 0, 0, 0, 0, 0]  # 1: 펀드 구매, 0: 펀드 미구매
}

# 페이지 이름을 숫자로 인코딩
encoder = LabelEncoder()
data['page'] = encoder.fit_transform(data['page'])

# 사용자별 시퀀스 데이터 준비
user_sequences = {}
user_labels = {}

for i in range(len(data['user_id'])):
    user_id = data['user_id'][i]
    if user_id not in user_sequences:
        user_sequences[user_id] = []
        user_labels[user_id] = data['label'][i]
    user_sequences[user_id].append(data['page'][i])

# 시퀀스를 패딩하여 길이 맞추기
X = pad_sequences(list(user_sequences.values()), padding='post')
y = torch.tensor(list(user_labels.values()), dtype=torch.float32)

# 학습 데이터와 테스트 데이터 분리
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 텐서 변환
X_train = torch.tensor(X_train, dtype=torch.long)
X_test = torch.tensor(X_test, dtype=torch.long)
y_train = y_train.view(-1, 1)
y_test = y_test.view(-1, 1)
```

### 2. 모델 정의

1D Convolutional Neural Network(Conv1D) 모델을 정의합니다. 이 모델은 고객의 페이지 방문 시퀀스를 입력으로 받아 펀드 상품 구매 여부를 예측합니다.

```python
class Conv1DModel(nn.Module):
    def __init__(self, vocab_size, embed_dim, num_filters, kernel_size, output_dim):
        super(Conv1DModel, self).__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        self.conv1d = nn.Conv1d(in_channels=embed_dim, out_channels=num_filters, kernel_size=kernel_size)
        self.relu = nn.ReLU()
        self.pool = nn.MaxPool1d(kernel_size=2)
        self.fc = nn.Linear(num_filters, output_dim)
        self.sigmoid = nn.Sigmoid()

    def forward(self, x):
        x = self.embedding(x)
        x = x.permute(0, 2, 1)  # Conv1D에 맞게 입력 형태 조정 (batch_size, embed_dim, seq_length)
        x = self.conv1d(x)
        x = self.relu(x)
        x = self.pool(x)
        x = x.view(x.size(0), -1)  # Flatten
        x = self.fc(x)
        x = self.sigmoid(x)
        return x

# 모델 하이퍼파라미터
vocab_size = len(encoder.classes_)  # 페이지 이름의 총 개수
embed_dim = 8  # 임베딩 차원
num_filters = 16  # Conv1D 필터 수
kernel_size = 3  # 필터 크기
output_dim = 1  # 출력 차원 (펀드 구매 여부)

model = Conv1DModel(vocab_size, embed_dim, num_filters, kernel_size, output_dim)
```

### 3. 모델 학습

```python
# 손실 함수 및 옵티마이저 정의
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)

# 학습 루프
num_epochs = 10
for epoch in range(num_epochs):
    model.train()
    optimizer.zero_grad()
    outputs = model(X_train)
    loss = criterion(outputs, y_train)
    loss.backward()
    optimizer.step()

    print(f'Epoch {epoch + 1}/{num_epochs}, Loss: {loss.item()}')

# 모델 평가
model.eval()
with torch.no_grad():
    predictions = model(X_test)
    predictions = (predictions > 0.5).float()
    accuracy = (predictions == y_test).float().mean()
    print(f'Accuracy: {accuracy.item() * 100:.2f}%')
```

### 4. 코드 설명

1. **데이터 전처리**:
   - **Label Encoding**: 페이지 이름을 숫자로 변환하여 모델에 입력할 수 있게 준비합니다.
   - **Padding**: 시퀀스 데이터의 길이를 통일하기 위해 `pad_sequences`를 사용합니다.
   - **Train/Test Split**: 데이터를 학습 및 테스트 세트로 분리합니다.

2. **Conv1D 모델**:
   - **Embedding Layer**: 페이지 이름을 고정된 차원의 벡터로 변환합니다.
   - **Conv1D Layer**: 1D 합성곱을 사용하여 시퀀스 데이터를 처리합니다.
   - **MaxPooling Layer**: 특성을 다운샘플링하여 중요 정보를 추출합니다.
   - **Fully Connected Layer**: 마지막 출력층으로 펀드 상품 구매 여부를 예측합니다.

3. **학습**:
   - **Binary Cross-Entropy Loss**: 이진 분류 문제이므로 BCE 손실 함수를 사용합니다.
   - **Adam Optimizer**: 학습을 위해 Adam 옵티마이저를 사용합니다.

4. **모델 평가**:
   - 학습된 모델을 사용해 테스트 세트에 대한 정확도를 계산합니다.

이 코드를 기반으로, 페이지 시퀀스를 입력으로 받아 고객이 펀드 상품을 구매할지 여부를 예측하는 1D Convolutional Neural Network를 구현할 수 있습니다. 필요에 따라 모델 하이퍼파라미터나 데이터 전처리 방법을 조정해 성능을 개선할 수 있습니다.