import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import classification_report, confusion_matrix
import matplotlib.pyplot as plt
import seaborn as sns

# 데이터 불러오기
df = pd.read_csv('customer_purchase_data.csv')

# 기본 정보 확인
print(df.head())
print(df.info())
print(df.describe())

# 종속변수 분포 확인
print(df['product_choice'].value_counts())

# 결측치 처리
df = df.dropna()  # 또는 df.fillna(df.mean())

# 특성과 타겟 분리
X = df[['age', 'income', 'visit_frequency', 'avg_purchase_amount', 
        'days_since_last_purchase']]
y = df['product_choice']  # 0: 제품A, 1: 제품B, 2: 제품C

# 학습/테스트 데이터 분할 (80:20)
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

# 특성 스케일링
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)

# 다항 로지스틱 회귀 모델 생성
model = LogisticRegression(
    multi_class='multinomial',  # 다항 분류
    solver='lbfgs',              # 최적화 알고리즘
    max_iter=1000,               # 최대 반복 횟수
    random_state=42
)

# 모델 학습
model.fit(X_train_scaled, y_train)

# 학습 완료!
print("모델 학습 완료! 🎉")

# 예측하기
y_pred = model.predict(X_test_scaled)

# 예측 확률 보기
y_pred_proba = model.predict_proba(X_test_scaled)
print("첫 번째 샘플의 각 클래스별 확률:")
print(f"제품A: {y_pred_proba[0][0]:.2%}")
print(f"제품B: {y_pred_proba[0][1]:.2%}")
print(f"제품C: {y_pred_proba[0][2]:.2%}")

# 정확도 계산
accuracy = model.score(X_test_scaled, y_test)
print(f"\n모델 정확도: {accuracy:.2%}")

# 혼동 행렬 계산
cm = confusion_matrix(y_test, y_pred)

# 시각화
plt.figure(figsize=(10, 8))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
            xticklabels=['제품A', '제품B', '제품C'],
            yticklabels=['제품A', '제품B', '제품C'])
plt.ylabel('실제값')
plt.xlabel('예측값')
plt.title('혼동 행렬')
plt.show()

# 분류 리포트 출력
print(classification_report(y_test, y_pred,
                          target_names=['제품A', '제품B', '제품C']))

# 각 클래스별 계수 확인
feature_names = ['나이', '소득', '방문빈도', '평균구매액', '최근구매일']
classes = ['제품A', '제품B', '제품C']

# 계수를 데이터프레임으로 정리
coef_df = pd.DataFrame(
    model.coef_,
    columns=feature_names,
    index=classes
)

print(coef_df)

# 히트맵으로 시각화
plt.figure(figsize=(12, 6))
sns.heatmap(coef_df, annot=True, cmap='RdBu_r', center=0,
            fmt='.3f', linewidths=1)
plt.title('특성별 계수 (클래스별)')
plt.tight_layout()
plt.show()

from sklearn.model_selection import GridSearchCV

# 탐색할 파라미터 그리드 정의
param_grid = {
    'C': [0.001, 0.01, 0.1, 1, 10, 100],
    'solver': ['lbfgs', 'newton-cg', 'sag'],
    'max_iter': [100, 500, 1000]
}

# 그리드 서치 객체 생성
grid_search = GridSearchCV(
    LogisticRegression(multi_class='multinomial', random_state=42),
    param_grid,
    cv=5,  # 5-fold 교차 검증
    scoring='accuracy',
    n_jobs=-1,  # 모든 CPU 코어 사용
    verbose=1
)

# 그리드 서치 실행
grid_search.fit(X_train_scaled, y_train)

# 최적 파라미터 출력
print("최적 파라미터:", grid_search.best_params_)
print("최고 정확도:", grid_search.best_score_)

# 최적 모델로 예측
best_model = grid_search.best_estimator_
y_pred_optimized = best_model.predict(X_test_scaled)

from sklearn.preprocessing import PolynomialFeatures

# 다항 특성 생성 (2차까지)
poly = PolynomialFeatures(degree=2, include_bias=False)
X_poly = poly.fit_transform(X)

# 상호작용 특성 수동 생성
df['income_age_interaction'] = df['income'] * df['age']
df['purchase_frequency_ratio'] = df['visit_frequency'] / df['avg_purchase_amount']

# 비닝
df['age_group'] = pd.cut(df['age'], 
                         bins=[0, 30, 40, 50, 100],
                         labels=['20대이하', '30대', '40대', '50대이상'])

# 시간 특성
df['days_since_purchase_category'] = pd.cut(df['days_since_last_purchase'],
                                             bins=[0, 7, 30, 90, 365],
                                             labels=['1주일이내', '1개월이내', 
                                                    '3개월이내', '1년이내'])

def recommend_product(customer_features, model, scaler, threshold=0.3):
    """
    고객 특성을 받아서 추천 제품 반환
    
    Parameters:
    - customer_features: 고객의 특성 데이터 (dict 또는 array)
    - model: 학습된 로지스틱 회귀 모델
    - scaler: 학습에 사용한 스케일러
    - threshold: 추천 확률 임계값
    
    Returns:
    - recommendations: 추천 제품 리스트
    """
    # 특성 스케일링
    features_scaled = scaler.transform([customer_features])
    
    # 각 제품별 선택 확률 예측
    probabilities = model.predict_proba(features_scaled)[0]
    
    # 제품명과 확률 매핑
    products = ['제품A', '제품B', '제품C']
    product_probs = dict(zip(products, probabilities))
    
    # 임계값 이상인 제품만 추천
    recommendations = {
        product: prob 
        for product, prob in product_probs.items() 
        if prob >= threshold
    }
    
    # 확률 높은 순으로 정렬
    recommendations = dict(
        sorted(recommendations.items(), 
               key=lambda x: x[1], 
               reverse=True)
    )
    
    return recommendations

# 사용 예시
customer = {
    'age': 35,
    'income': 5500,
    'visit_frequency': 12,
    'avg_purchase_amount': 85000,
    'days_since_last_purchase': 15
}

recommendations = recommend_product(customer, best_model, scaler)
print("추천 제품:")
for product, prob in recommendations.items():
    print(f"  {product}: {prob:.1%} 확률")

from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
from sklearn.ensemble import StackingClassifier

# 베이스 모델들 정의
base_models = [
    ('lr', LogisticRegression(multi_class='multinomial', max_iter=1000)),
    ('rf', RandomForestClassifier(n_estimators=100, random_state=42)),
    ('gb', GradientBoostingClassifier(n_estimators=100, random_state=42))
]

# 메타 모델 정의
meta_model = LogisticRegression(multi_class='multinomial')

# 스태킹 앙상블 생성
stacking_model = StackingClassifier(
    estimators=base_models,
    final_estimator=meta_model,
    cv=5
)

# 학습
stacking_model.fit(X_train_scaled, y_train)

# 예측
y_pred_stacking = stacking_model.predict(X_test_scaled)
accuracy_stacking = stacking_model.score(X_test_scaled, y_test)
print(f"스태킹 앙상블 정확도: {accuracy_stacking:.2%}")

from statsmodels.stats.outliers_influence import variance_inflation_factor

# VIF 계산
vif_data = pd.DataFrame()
vif_data["특성"] = X.columns
vif_data["VIF"] = [variance_inflation_factor(X.values, i) 
                   for i in range(len(X.columns))]
print(vif_data)

# VIF > 10이면 다중공선성 의심
# VIF > 5도 주의가 필요