💰 AWS ML로 AWS 비용 예측하기 프로젝트

# 시나리오 1: 2023년 학습 → 2024년 예측
- 학습 데이터: 2023년 12개월
- 예측 대상: 2024년 12개월
- 검증 방법: 2024년 실제 데이터와 비교 (현재 가능)

# 시나리오 2: 2023-2024년 학습 → 2025년 예측
- 학습 데이터: 2023-2024년 24개월
- 예측 대상: 2025년 12개월
- 검증 방법: 2025년 실제 데이터와 비교 (진행 중)

# 기본 가정
- 3년간의 데이터는 패턴 학습에 충분
- 과거 데이터 패턴이 미래 예측에 유효
- 머신러닝 알고리즘을 통한 정확도 향상 가능
- 다중 시나리오 검증을 통한 모델 신뢰성 확보

# Athena에서 CSM 데이터 조회
query = """
SELECT year, month, usageaccountid, productcode, 
       SUM(unblendedcost) as monthly_cost,
       SUM(amortized_cost) as amortized_monthly_cost
FROM awsbilling.summary_view 
WHERE year >= '2023'
GROUP BY year, month, usageaccountid, productcode
ORDER BY year, month
"""

# 월별 총 비용 집계 및 시계열 데이터 생성
monthly_totals = df.groupby('date')['monthly_cost'].sum().reset_index()
monthly_totals = monthly_totals.sort_values('date')

# 기본 시계열 특성
monthly_totals['month_index'] = range(len(monthly_totals))  # 순차 인덱스
monthly_totals['month_num'] = monthly_totals['date'].dt.month  # 월 (1-12)
monthly_totals['quarter'] = monthly_totals['date'].dt.quarter  # 분기 (1-4)

# 이동평균 특성 (트렌드 파악)
monthly_totals['ma_3'] = monthly_totals['monthly_cost'].rolling(3).mean()  # 3개월 이동평균
monthly_totals['ma_6'] = monthly_totals['monthly_cost'].rolling(6).mean()  # 6개월 이동평균

# 모델 정의
models = {
    'rf': RandomForestRegressor(n_estimators=100, random_state=42),
    'lr': LinearRegression()
}

# 특성 변수 선택
features = ['month_index', 'month_num', 'quarter', 'ma_3', 'ma_6']
X = train_data[features].fillna(method='bfill')
y = train_data['monthly_cost']

# 모델 학습
for name, model in models.items():
    model.fit(X, y)

# 2025년 예측을 위한 특성 생성
future_months = pd.date_range(start='2025-01-01', periods=12, freq='MS')
future_features = []

for i, date in enumerate(future_months):
    # 과거 데이터 기반 이동평균 계산
    recent_costs = train_data['monthly_cost'].tail(6).values
    ma_3 = np.mean(recent_costs[-3:]) if len(recent_costs) >= 3 else recent_costs.mean()
    ma_6 = np.mean(recent_costs) if len(recent_costs) >= 6 else recent_costs.mean()
    
    future_features.append({
        'month_index': len(train_data) + i,
        'month_num': date.month,
        'quarter': date.quarter,
        'ma_3': ma_3,
        'ma_6': ma_6
    })

# 예측 실행
predictions = {}
for name, model in models.items():
    pred = model.predict(future_X)
    predictions[name] = pred

# 다양한 윈도우 이동평균
df['ma_2'] = df['total_cost'].rolling(2, min_periods=1).mean()  # 2개월
df['ma_3'] = df['total_cost'].rolling(3, min_periods=1).mean()  # 3개월  
df['ma_6'] = df['total_cost'].rolling(6, min_periods=1).mean()  # 6개월

# 변화율 특성
df['mom_change'] = df['total_cost'].pct_change()  # 월간 변화율
df['mom_change_ma3'] = df['mom_change'].rolling(3, min_periods=1).mean()  # 변화율 평활화

# 삼각함수를 이용한 계절성 표현
df['sin_month'] = np.sin(2 * np.pi * df['month_num'] / 12)
df['cos_month'] = np.cos(2 * np.pi * df['month_num'] / 12)
df['sin_quarter'] = np.sin(2 * np.pi * df['quarter'] / 4)
df['cos_quarter'] = np.cos(2 * np.pi * df['quarter'] / 4)

# 이유: 12월과 1월의 연속성을 수학적으로 표현
# sin/cos 조합으로 원형 시간 구조 모델링

# 변동성 측정
df['volatility_3m'] = df['total_cost'].rolling(3, min_periods=1).std()
df['volatility_6m'] = df['total_cost'].rolling(6, min_periods=1).std()

# 트렌드 분석
df['linear_trend'] = np.arange(len(df))
df['detrended_cost'] = df['total_cost'] - (df['linear_trend'] * df['total_cost'].diff().mean())

# 비즈니스 특성 (도메인 지식 반영)
df['is_q1'] = (df['quarter'] == 1).astype(int)  # 신년 예산 증가 효과
df['is_q4'] = (df['quarter'] == 4).astype(int)  # 연말 지출 증가 효과
df['is_year_end'] = (df['month_num'] >= 11).astype(int)  # 연말 효과

class ImprovedBudgetPredictor:
    def __init__(self):
        self.models = {
            'rf': RandomForestRegressor(n_estimators=200, random_state=42),
            'gb': GradientBoostingRegressor(n_estimators=100, random_state=42),
            'lr': LinearRegression()
        }
        # 가중 평균을 위한 가중치 설정
        self.weights = {'rf': 0.4, 'gb': 0.4, 'lr': 0.2}
    
    def predict_ensemble(self, X):
        """앙상블 예측"""
        predictions = {}
        for name, model in self.models.items():
            predictions[name] = model.predict(X)
        
        # 가중 평균 계산
        ensemble_pred = (
            predictions['rf'] * self.weights['rf'] +
            predictions['gb'] * self.weights['gb'] +
            predictions['lr'] * self.weights['lr']
        )
        return ensemble_pred

# 실제 vs 예측 비교 (2025년 1-5월)
actual_2025 = [
    {"month": "01", "actual_cost": 731337.61},
    {"month": "02", "actual_cost": 576939.76},
    {"month": "03", "actual_cost": 616179.57},
    {"month": "04", "actual_cost": 607998.79},
    {"month": "05", "actual_cost": 592674.50}
]

predictions_2025 = [
    {"month": "01", "predicted_cost": 881207},
    {"month": "02", "predicted_cost": 876152},
    {"month": "03", "predicted_cost": 851643},
    {"month": "04", "predicted_cost": 888317},
    {"month": "05", "predicted_cost": 845591}
]

# 오차 계산
for i in range(5):
    actual = actual_2025[i]['actual_cost']
    predicted = predictions_2025[i]['predicted_cost']
    error = abs(predicted - actual) / actual * 100
    print(f"2025-{i+1:02d}: {error:.1f}% 오차")

# QuickSight 대시보드 자동 생성
def create_budget_dashboard():
    quicksight = boto3.client('quicksight')
    
    # 데이터셋 생성
    response = quicksight.create_data_set(
        AwsAccountId=account_id,
        DataSetId='budget-prediction-dataset',
        Name='Budget Prediction Analysis',
        PhysicalTableMap={
            'budget-table': {
                'S3Source': {
                    'DataSourceArn': athena_datasource_arn,
                    'InputColumns': [
                        {'Name': 'date', 'Type': 'DATETIME'},
                        {'Name': 'actual_cost', 'Type': 'DECIMAL'},
                        {'Name': 'predicted_cost', 'Type': 'DECIMAL'}
                    ]
                }
            }
        }
    )
    
    # 시각화 생성 (시계열 차트, 오차 분석 등)
    return create_visualizations()

# 핵심: 단순함이 승리
model = Prophet(
    changepoint_prior_scale=0.01,  # 트렌드 변화 민감도 낮춤
    seasonality_prior_scale=1.0,   # 계절성 강도 조절
    seasonality_mode='additive'    # 단순한 덧셈 모드
)

# 최소한의 비즈니스 특성만
model.add_regressor('is_year_end')  # 연말 효과
model.add_regressor('is_q1')        # 신년 효과

# 최적화된 Prophet 핵심 코드
def build_simple_prophet_model(df):
    model = Prophet(
        yearly_seasonality=True,
        weekly_seasonality=False,
        daily_seasonality=False,
        changepoint_prior_scale=0.01,  # 과적합 방지
        seasonality_prior_scale=1.0,   # 계절성 조절
        seasonality_mode='additive'
    )
    
    # 핵심 특성만
    model.add_regressor('is_year_end')
    model.add_regressor('is_q1')
    
    return model

# 예측 실행
model.fit(df)
future = model.make_future_dataframe(periods=12, freq='MS')
forecast = model.predict(future)