해색주의 조용한 공간

큰 데이터셋의 경우, SQL에서 페이지 이동 정보를 사전에 요약하여 Python으로 가져오는 방식이 훨씬 효율적일 수 있습니다. 이 방법은 각 `page_id`에서 `next_page_id`로의 전환이 얼마나 자주 발생했는지를 미리 계산한 후, Python에서 그래프 형태로 시각화할 수 있습니다.

SQL 단계에서 요약된 데이터를 만드는 방법은 `GROUP BY`와 `COUNT()`를 활용하여 각 페이지 간 전환 빈도를 집계하는 것입니다.

### 1. SQL로 페이지 이동 요약하기

다음 SQL 쿼리는 `page_id`에서 `next_page_id`로의 전환 빈도를 사전에 계산합니다.

```sql
-- Teradata에서 page_id와 next_page_id의 전환을 요약한 SQL 쿼리
SELECT 
    page_id,
    next_page_id,
    COUNT(*) AS transition_count
FROM (
    SELECT 
        session_id,
        page_id,
        LEAD(page_id) OVER (PARTITION BY session_id ORDER BY event_time) AS next_page_id
    FROM 
        your_table
) t
WHERE next_page_id IS NOT NULL
GROUP BY page_id, next_page_id;
```

#### 쿼리 설명:
- **`LEAD()`**: `page_id`의 다음 페이지를 가져옵니다.
- **`GROUP BY`**: `page_id`와 `next_page_id`별로 그룹화하여 전환 빈도를 계산합니다.
- **`COUNT(*)`**: 각 전환(`page_id` -> `next_page_id`)이 발생한 횟수를 집계합니다.

이렇게 사전에 전환 빈도를 요약하면, 큰 데이터셋도 효율적으로 처리할 수 있습니다.

### 2. Python에서 요약된 데이터로 그래프 그리기

이제, 요약된 데이터를 Python으로 가져와서 페이지 이동을 시각화합니다.

```python
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
from sqlalchemy import create_engine

# Teradata 연결 설정 (SQLAlchemy 사용)
engine = create_engine('teradata://username:password@host:port/dbname')

# SQL 쿼리로 요약된 데이터 불러오기
query = """
SELECT 
    page_id,
    next_page_id,
    COUNT(*) AS transition_count
FROM (
    SELECT 
        session_id,
        page_id,
        LEAD(page_id) OVER (PARTITION BY session_id ORDER BY event_time) AS next_page_id
    FROM 
        your_table
) t
WHERE next_page_id IS NOT NULL
GROUP BY page_id, next_page_id;
"""

# Teradata에서 데이터를 읽어와 DataFrame으로 저장
df = pd.read_sql(query, engine)

# 엣지 리스트 만들기 (page_id -> next_page_id)와 가중치 추가
edges = df[['page_id', 'next_page_id', 'transition_count']].values.tolist()

# NetworkX 그래프 객체 생성
G = nx.DiGraph()

# 엣지와 가중치를 그래프에 추가
for edge in edges:
    G.add_edge(edge[0], edge[1], weight=edge[2])

# 그래프 시각화 설정
plt.figure(figsize=(8, 6))
pos = nx.spring_layout(G)

# 노드 및 엣지 시각화
nx.draw(G, pos, with_labels=True, node_color='skyblue', node_size=3000, font_size=12, font_weight='bold', edge_color='gray', arrows=True)

# 엣지 가중치(전환 빈도) 표시
edge_labels = nx.get_edge_attributes(G, 'weight')
nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)

# 그래프 보여주기
plt.title('Page Transitions with Frequency')
plt.show()
```

### 코드 설명:
1. **Teradata에서 요약된 데이터 가져오기**: SQL 쿼리에서 페이지 전환 빈도(`transition_count`)를 포함한 데이터를 Python으로 가져옵니다.
2. **엣지 리스트 생성**: `page_id`, `next_page_id`, 그리고 전환 빈도(`transition_count`)를 포함한 리스트를 생성합니다.
3. **그래프에 가중치 추가**: 각 엣지에 페이지 간 전환 빈도를 가중치로 추가합니다.
4. **NetworkX 그래프 시각화**: 페이지 간 이동을 그래프로 나타내고, 각 엣지에 전환 빈도를 라벨로 표시합니다.

### 요약:
- **SQL에서 요약**: Teradata SQL에서 페이지 이동 전환을 미리 집계하여 전환 빈도를 계산합니다.
- **Python에서 시각화**: 요약된 데이터를 `NetworkX`로 시각화하며, 각 전환 빈도를 엣지 가중치로 표시합니다.

이 방법은 데이터가 매우 클 때도 효율적으로 처리할 수 있으며, SQL에서 최대한 전처리를 진행하여 Python에서 시각화에 집중할 수 있습니다.

고객의 `page_id` 이동 정보를 분석하고, 세션 내에서 페이지 간의 연결을 시각화하는 작업을 Python의 `networkx`를 사용해 구현할 수 있습니다. 아래는 이를 위한 예제 코드입니다.

### 예제 코드

```python
import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt

# 샘플 데이터프레임 생성
data = {
    'session_id': [1, 1, 1, 2, 2, 3, 3, 3],
    'customer_id': [101, 101, 101, 102, 102, 103, 103, 103],
    'page_id': ['home', 'product', 'cart', 'home', 'checkout', 'home', 'product', 'cart']
}

df = pd.DataFrame(data)

# 페이지 이동 정보를 담은 그래프 생성 함수
def build_page_transition_graph(df):
    # 세션별로 그룹화하여 페이지 이동 순서를 파악
    G = nx.DiGraph()  # 방향 그래프를 사용하여 페이지 이동을 나타냄
    
    for session, group in df.groupby('session_id'):
        pages = group['page_id'].tolist()
        # 각 세션 내 페이지 이동을 간선으로 추가
        for i in range(len(pages) - 1):
            G.add_edge(pages[i], pages[i+1])
    
    return G

# 그래프 생성
G = build_page_transition_graph(df)

# 페이지 이동의 연결 강도 계산 (간선의 가중치 추가)
for (u, v) in G.edges():
    if G.has_edge(u, v):
        if 'weight' in G[u][v]:
            G[u][v]['weight'] += 1
        else:
            G[u][v]['weight'] = 1

# 그래프 시각화 함수
def plot_graph(G):
    pos = nx.spring_layout(G)  # 그래프의 레이아웃 설정
    weights = [G[u][v]['weight'] for u, v in G.edges()]  # 간선의 가중치
    
    plt.figure(figsize=(10, 7))
    nx.draw_networkx_nodes(G, pos, node_color='skyblue', node_size=2000)
    nx.draw_networkx_edges(G, pos, width=weights, edge_color='gray', arrows=True)
    nx.draw_networkx_labels(G, pos, font_size=12, font_color='black')

    plt.title('Page Transition Graph')
    plt.show()

# 그래프 시각화
plot_graph(G)

# 연결이 많이 된 page_id 추출
most_connected_pages = sorted(G.degree, key=lambda x: x[1], reverse=True)
print("Most connected pages:", most_connected_pages)
```

### 코드 설명
1. **데이터 생성**: `session_id`, `customer_id`, `page_id`로 구성된 데이터프레임을 만듭니다.
2. **`build_page_transition_graph` 함수**: 각 세션 내에서 페이지 이동 정보를 추출하여 방향성 그래프(DiGraph)를 만듭니다.
   - 각 세션의 페이지 이동이 간선으로 추가됩니다.
3. **간선 가중치 계산**: 페이지 이동이 얼마나 자주 발생했는지, 간선의 가중치로 설정합니다.
4. **`plot_graph` 함수**: `networkx`와 `matplotlib`을 사용해 페이지 이동 네트워크를 시각화합니다.
5. **가장 많이 연결된 페이지 추출**: 페이지별 연결 강도를 기준으로 정렬해 가장 많이 연결된 페이지를 출력합니다.

### 결과:
- 이 코드는 각 세션에서 페이지 간의 이동을 시각적으로 보여주며, 페이지 이동 횟수에 따른 간선의 굵기가 조정됩니다.
- 또한, 가장 연결이 많이 된 페이지도 출력됩니다.

고객이 앱에서 페이지 방문 패턴을 시각화하는 방법을 한국어로 설명드릴게요.

### 1. **데이터 수집 및 준비**
   - **데이터 로깅**: 사용자의 페이지 방문, 타임스탬프, 사용자 ID, 세션 ID, 페이지 체류 시간 등과 같은 중요한 상호작용 데이터를 기록해야 합니다.
   - **데이터 정리**: 각 세션을 사용자가 방문한 페이지 순서와 타임스탬프로 정리하여 사용자 경로를 명확히 파악할 수 있도록 합니다.

### 2. **주요 시각화 기법**

   #### a. **Sankey 다이어그램 (흐름 차트)**
   - **목적**: 고객이 앱에서 각 페이지 간 어떻게 이동하는지를 보여줍니다. 첫 번째로 방문한 페이지와 이후에 어떻게 이동했는지, 이탈하는 지점을 확인할 수 있습니다.
   - **도구**: D3.js, Plotly (Python), Power BI 등에서 Sankey 다이어그램을 만들 수 있습니다.
   - **예시**: 사용자가 첫 페이지에서 두 번째 페이지로 얼마나 이동했는지, 특정 페이지에서 많이 이탈하는지 등을 보여줍니다.

   #### b. **히트맵 (Heatmap)**
   - **목적**: 특정 페이지 내에서 사용자가 가장 많이 상호작용하는 부분을 색상으로 시각화합니다. 예를 들어, 버튼 클릭이나 스크롤 등 특정 요소의 사용 빈도를 볼 수 있습니다.
   - **도구**: Google Analytics, Hotjar 같은 도구를 사용하거나, Matplotlib와 Seaborn 같은 라이브러리로 직접 히트맵을 만들 수 있습니다.
   - **예시**: 사용자들이 특정 페이지에서 가장 많이 클릭하는 영역을 시각화하여 중요한 행동을 분석할 수 있습니다.

   #### c. **순차 패턴 분석 (Sequential Pattern Analysis)**
   - **목적**: 사용자가 앱에서 페이지를 방문하는 순서를 분석하고, 자주 발생하는 패턴을 찾아냅니다. 이를 통해 사용자가 주로 어떤 경로로 앱을 사용하는지 파악할 수 있습니다.
   - **도구**: Markov Chain 모델이나 Python의 `mlxtend` 라이브러리를 사용해 분석할 수 있습니다.
   - **예시**: 사용자가 홈 페이지 → 제품 페이지 → 결제 페이지로 이동하는 빈도를 분석할 수 있습니다.

### 3. **실행 방법**
   - 데이터를 적절히 정리한 후, 위에 언급된 시각화 도구와 기법을 사용하여 고객의 앱 내 페이지 방문 패턴을 시각화할 수 있습니다. 
   - 이러한 시각화는 고객의 이동 경로, 이탈 지점, 주요 상호작용 포인트를 명확히 보여주어 UX 개선이나 마케팅 전략에 중요한 인사이트를 제공합니다.

이해가 쉽게 되었나요? 추가로 궁금한 부분이 있으면 알려주세요!

순차 패턴 분석(Sequential Pattern Analysis)은 사용자가 특정 순서대로 어떤 페이지를 방문하는지 분석하는 데 유용합니다. 파이썬에서는 `mlxtend` 라이브러리를 사용하여 간단한 연관 규칙 기반의 순차 패턴 분석을 수행할 수 있습니다. 여기서는 **Markov Chain 모델**을 기반으로 하는 순차 패턴 분석의 예제를 살펴보겠습니다.

### 1. **설치**
먼저 필요한 라이브러리를 설치해야 합니다:

```bash
pip install mlxtend
```

### 2. **데이터 준비**
사용자 세션 데이터를 리스트로 정리해봅니다. 각 사용자가 페이지를 방문한 순서에 따라 데이터를 정리해야 합니다.

#### 예시 데이터 (사용자 ID별 페이지 방문 순서):
```python
# 예제: 사용자별 페이지 방문 기록
sessions = [
    ['home', 'product', 'cart', 'checkout'],  # 세션 1
    ['home', 'search', 'product', 'checkout'],  # 세션 2
    ['home', 'product', 'checkout'],  # 세션 3
    ['home', 'search', 'product'],  # 세션 4
    ['product', 'cart', 'checkout'],  # 세션 5
    ['home', 'cart', 'checkout'],  # 세션 6
]
```

### 3. **순차 패턴 분석: Markov Chain**
Markov Chain 모델은 사용자가 현재 상태에서 다음 상태로 이동할 확률을 계산하는 데 적합합니다. 여기서는 각 페이지에서 다른 페이지로 이동할 확률을 계산하는 예제를 살펴봅니다.

#### 단계별로 수행되는 과정:

```python
import pandas as pd
from collections import defaultdict

# 데이터: 사용자 방문 기록
sessions = [
    ['home', 'product', 'cart', 'checkout'],
    ['home', 'search', 'product', 'checkout'],
    ['home', 'product', 'checkout'],
    ['home', 'search', 'product'],
    ['product', 'cart', 'checkout'],
    ['home', 'cart', 'checkout'],
]

# 페이지 전환 횟수 계산
transitions = defaultdict(lambda: defaultdict(int))

for session in sessions:
    for i in range(len(session) - 1):
        current_page = session[i]
        next_page = session[i + 1]
        transitions[current_page][next_page] += 1

# 전환 확률 계산
transition_probabilities = defaultdict(dict)

for current_page, next_pages in transitions.items():
    total_visits = sum(next_pages.values())
    for next_page, count in next_pages.items():
        transition_probabilities[current_page][next_page] = count / total_visits

# 결과 출력
df = pd.DataFrame(transition_probabilities).fillna(0)
print(df)
```

### 4. **결과 분석**
이 코드는 각 페이지에서 다른 페이지로 이동할 확률을 계산합니다. 예를 들어, 사용자가 'home'에서 'product'로 이동할 확률과 'home'에서 'search'로 이동할 확률을 보여줍니다.

#### 예시 출력:

```
           cart  checkout  product  search
cart        0.0      1.00     0.00    0.00
checkout    0.0      0.00     0.00    0.00
home        0.2      0.00     0.60    0.20
product     0.5      0.50     0.00    0.00
search      0.0      0.00     1.00    0.00
```

#### 해석:
- `home` 페이지에서 `product`로 이동할 확률은 60%, `search`로 이동할 확률은 20%입니다.
- `product`에서 `checkout`으로 이동할 확률은 50%, `cart`로 이동할 확률은 50%입니다.

### 5. **시각화 (선택 사항)**
Markov Chain 모델을 시각화하기 위해 네트워크 그래프를 그릴 수 있습니다.

```python
import networkx as nx
import matplotlib.pyplot as plt

# 그래프 생성
G = nx.DiGraph()

# 엣지 추가 (페이지 간 확률 기반)
for current_page, next_pages in transition_probabilities.items():
    for next_page, prob in next_pages.items():
        G.add_edge(current_page, next_page, weight=prob)

# 시각화
pos = nx.spring_layout(G)
edges = G.edges(data=True)
weights = [edge[2]['weight'] for edge in edges]

nx.draw(G, pos, with_labels=True, node_size=3000, node_color='skyblue', font_size=10, width=weights)
plt.show()
```

이 코드를 실행하면 페이지 간 이동 확률을 시각화한 네트워크 그래프가 표시됩니다. 각 페이지는 노드로 표현되고, 이동할 확률은 엣지의 두께로 표시됩니다.

### 결론
위 코드를 통해 사용자가 앱 내에서 어떻게 페이지를 이동하는지, 어떤 페이지 간 이동이 자주 발생하는지 파악할 수 있습니다. 이를 통해 이탈 지점을 분석하거나, 주요 페이지 경로를 최적화할 수 있습니다.

**PCA (Principal Component Analysis)**와 **PLS (Partial Least Squares)**는 모두 차원 축소 기법으로, 고차원 데이터를 처리할 때 중요한 정보를 유지하면서 데이터의 차원을 줄이는 데 사용됩니다. 그러나 두 방법의 목표와 작동 방식에는 차이가 있습니다. PCA는 **비지도 학습** 방식으로, PLS는 **지도 학습** 방식으로 차원을 축소하고 변수들을 변환하는 방법입니다.

### 1. **PCA (주성분 분석)**
**PCA**는 데이터의 차원을 축소하는 **비지도 학습** 방법입니다. 데이터를 몇 개의 **주성분(Principal Components)**으로 변환하여, 각 주성분이 데이터의 분산을 최대한 많이 설명할 수 있도록 만듭니다.

#### PCA의 핵심 특징:
- **목적**: 데이터의 **분산**을 최대한 설명하는 새로운 축(주성분)을 찾는 것.
- **입력 데이터**: 입력 데이터(X)만을 사용하고, 종속 변수(y)는 사용하지 않습니다.
- **방법**: 변수들 간의 **공분산** 구조를 분석해, 분산을 최대화하는 방향으로 데이터를 변환합니다. 주성분들은 서로 **직교(orthogonal)**하며, 각 주성분은 독립된 축을 형성합니다.
- **차원 축소**: 주성분을 몇 개 선택하느냐에 따라 차원을 축소합니다. 주성분들은 입력 변수들의 선형 결합으로 만들어집니다.
- **설명된 분산**: 첫 번째 주성분은 데이터의 분산을 가장 많이 설명하고, 두 번째 주성분은 첫 번째 주성분에 직교하면서 남은 분산을 최대한 설명하는 방식입니다.

#### PCA의 한계:
- **목표 변수와의 관계를 고려하지 않음**: PCA는 데이터의 분산에만 초점을 맞추므로, 목표 변수(y)가 있는 경우 그와의 상관관계를 고려하지 않습니다. 따라서 회귀나 분류 문제에서 직접적으로 최적화된 변수를 찾기에는 적합하지 않을 수 있습니다.

#### PCA의 활용:
- 데이터 시각화, 노이즈 제거, 다중 공선성 문제 해결, 차원 축소 후 분석 등을 위해 사용됩니다.

### 2. **PLS (부분 최소 제곱법)**
**PLS**는 회귀와 차원 축소를 결합한 **지도 학습** 기법입니다. **입력 변수(X)**와 **출력 변수(y)** 간의 관계를 최대한 잘 설명하는 **잠재 변수(latent variables)**를 찾는 것이 목표입니다. PLS는 X와 y를 모두 사용하여 두 집합 간의 공분산을 최대화하는 새로운 변수를 찾습니다.

#### PLS의 핵심 특징:
- **목적**: 입력 변수(X)와 출력 변수(y) 간의 **상관관계**를 최대화하는 방향으로 차원 축소.
- **입력 데이터**: 입력 데이터(X)와 출력 데이터(y)를 함께 사용하여, 두 데이터 집합 간의 관계를 고려합니다.
- **방법**: X와 y 간의 **공분산**을 최대화하는 잠재 변수를 찾습니다. PLS는 X와 y의 공분산 행렬을 이용해 변환을 수행하며, 그 결과 X의 변수를 변환하여 y와의 관계를 잘 설명하도록 만듭니다.
- **차원 축소 및 회귀**: PLS는 X의 차원을 줄이면서도, 목표 변수(y)를 예측하기 위한 회귀 모델을 구축할 수 있습니다.
- **다중 공선성 문제 해결**: PLS는 X 변수들 간의 상관관계를 고려하면서도 y와의 관계를 유지하므로, 다중 공선성 문제를 효과적으로 해결할 수 있습니다.

#### PLS의 장점:
- **목표 변수와의 관계를 최적화**: PLS는 차원 축소 시 y와의 관계를 반영하여, 회귀 문제에서 더 적합한 결과를 도출할 수 있습니다.
- **다중 공선성 해결**: X 변수들 간에 상관관계가 높아도, y와의 관계를 유지하면서 변수를 변환할 수 있습니다.
- **회귀 성능**: PLS는 X와 y 간의 관계를 최적화하므로, PCA보다 회귀 문제에서 더 나은 성능을 발휘하는 경우가 많습니다.

#### PLS의 활용:
- 회귀 분석, 예측 모델링, 다중 공선성 문제 해결, 고차원 데이터 분석 등에 주로 사용됩니다.

### 3. **PCA와 PLS의 차이점**

| 특성 | PCA | PLS |
| --- | --- | --- |
| **목적** | 데이터의 **분산**을 최대한 많이 설명하는 주성분을 찾음 | 입력(X)와 출력(y)의 **상관관계**를 최적화하면서 차원을 축소 |
| **입력 데이터** | 입력 데이터(X)만 사용 (비지도 학습) | 입력 데이터(X)와 출력 데이터(y)를 동시에 사용 (지도 학습) |
| **차원 축소 기준** | 데이터의 분산을 기준으로 차원 축소 | X와 y 간의 상관관계를 최대화하는 방향으로 차원 축소 |
| **결과 해석** | 주성분들이 원본 변수의 선형 결합으로 해석 | X와 y 간의 관계를 설명하는 잠재 변수를 통해 해석 |
| **다중 공선성 문제** | 다중 공선성 문제를 해결할 수 있지만 y와의 관계는 고려하지 않음 | 다중 공선성 문제 해결 및 y와의 관계를 반영 |
| **주요 응용** | 시각화, 데이터 구조 이해, 비지도 차원 축소 | 회귀 분석, 예측 모델링, 지도 차원 축소 |

### 4. **PCA와 PLS의 선택 기준**
- **PCA**는 **비지도 학습**으로 레이블(목표 값)이 없는 데이터에서 차원을 축소하거나, 데이터 구조를 탐색하고 싶을 때 적합합니다. 데이터의 분산이 주된 관심사일 경우 유용합니다.
- **PLS**는 **지도 학습**으로, 회귀 분석이나 예측 문제에서 차원 축소와 동시에 y와의 관계를 반영한 변수를 만들고 싶을 때 사용됩니다. 특히, X와 y 간의 상관관계가 중요한 경우에 PLS가 더 적합합니다.

### 요약
- **PCA**는 데이터를 몇 개의 주성분으로 변환하여 **데이터의 분산을 설명하는 방향**으로 차원을 축소하는 비지도 학습 방법입니다. 주로 데이터 구조 파악, 차원 축소, 시각화 등에 사용됩니다.
- **PLS**는 입력 데이터(X)와 출력 데이터(y) 간의 **상관관계를 최대화**하는 방향으로 차원을 축소하는 지도 학습 방법입니다. 주로 회귀 분석이나 예측 모델에서 활용되며, 다중 공선성 문제를 해결하고 X와 y 간의 관계를 유지하면서 차원을 축소하는 데 적합합니다.

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를 구현할 수 있습니다. 필요에 따라 모델 하이퍼파라미터나 데이터 전처리 방법을 조정해 성능을 개선할 수 있습니다.

 파이썬에서 pandas dataframe으로 자료를 전처리하고 텍스트 파일/CSV 파일로 내보내기를 할때 한글이 있으면 encoding = 'euc-kr'로 인코딩을 해줘야 한다.

 보통 'head -10 filename.txt' 이렇게 해주는데, Jupyterlab에서 해당 텍스트를 읽으려면 인코딩 때문에 깨져 나온다.

 이럴때 쓸 수 있는 방법이 바로 encoding해서 읽어내는 방법니다.

 !iconv -f EUR-KR -t UTF-8 filename.txt | head -3

 이렇게 해주면 한글도 정상적으로 잘 보인다.