conda create -n forecast python=3.12

conda activate forecast

# 基于 PyTorch 的時間序列預測工具，用來訓練模型并進行預測
pip install neuralprophet
# 用于處理Excel的庫，演示用數據保存在Excel
pip install openpyxl
# 用于構建網頁應用界面
pip install streamlit

cd /forecast
# 直接編輯，在保存時會生成文件
vim history_data.py

import numpy as np
import pandas as pd

# ============================
# 參數配置
# ============================
start_time = pd.Timestamp("2025-08-01 00:00:00")
end_time = pd.Timestamp("2025-08-31 23:59:59")
rng = pd.date_range(start=start_time, end=end_time, freq="10min")

periods = len(rng)
np.random.seed(42)  # 保證可復現

# ============================
# 輔助函數：日內波動模式
# ============================
def daily_pattern(minutes, amplitude=1.0, phase_shift=0):
    radians = (minutes / (24 * 60)) * 2 * np.pi
    return 0.5 + 0.5 * np.sin(radians - 0.3 + phase_shift)

minutes_from_start = (np.arange(periods) * 10) % (24 * 60)
weekday = rng.weekday  # 0=周一
hours = rng.hour

# ============================
# CPU
# ============================
cpu_base = 10 + 5 * (np.random.rand(periods) - 0.5)
cpu_daily = 25 * daily_pattern(minutes_from_start)
cpu = cpu_base + cpu_daily * np.where(weekday < 5, 1.0, 0.7)
spike_mask = (np.random.rand(periods) < 0.005)  # 偶發高峰
cpu[spike_mask] += np.random.uniform(20, 60, size=spike_mask.sum())

# ============================
# 內存
# ============================
mem_base = 50 + 10 * np.sin((np.arange(periods) / periods) * 2 * np.pi)
mem_noise = np.random.normal(0, 2.0, size=periods)
mem_weekday_effect = np.where(weekday < 5, 1.02, 0.99)
memory_used = mem_base * mem_weekday_effect + mem_noise
mem_spike_mask = (np.random.rand(periods) < 0.002)
memory_used[mem_spike_mask] += np.random.uniform(5, 20, size=mem_spike_mask.sum())
memory_used = np.clip(memory_used, 10, 99.5)

# ============================
# 磁盤使用率
# ============================
disk_start, disk_end = 60.0, 62.0
disk_trend = np.linspace(disk_start, disk_end, periods)
disk_noise = np.random.normal(0, 0.05, size=periods)
disk_used = np.clip(disk_trend + disk_noise, 20, 99.9)

# ============================
# 網絡流量
# ============================
net_in_base = 5 * daily_pattern(minutes_from_start) + 1.0
net_out_base = 3 * daily_pattern(minutes_from_start) + 0.5
lunch_mask = ((hours >= 11) & (hours <= 13))
net_in = net_in_base * (1.2 * np.where(weekday < 5, 1, 0.9))
net_out = net_out_base * (1.15 * np.where(weekday < 5, 1, 0.9))
net_in[lunch_mask] *= 1.3
net_out[lunch_mask] *= 1.2
burst_mask = (np.random.rand(periods) < 0.003)
net_in[burst_mask] += np.random.uniform(20, 200, size=burst_mask.sum())
net_out[burst_mask] += np.random.uniform(5, 80, size=burst_mask.sum())

# ============================
# 組合 DataFrame
# ============================
df_aug = pd.DataFrame({
    "ds": rng,
    "cpu": np.round(np.clip(cpu, 0, 100), 2),
    "memory": np.round(memory_used, 2),
    "disk": np.round(disk_used, 2),
    "net_in": np.round(net_in, 3),
    "net_out": np.round(net_out, 3)
})

# ============================
# 每小時統計（平均、最大、最小）
# ============================
df_hourly = df_aug.set_index("ds").resample("1h").agg(
    {
        "cpu": ["mean", "max", "min"],
        "memory": ["mean", "max", "min"],
        "disk": ["mean", "max", "min"],
        "net_in": ["mean", "max", "min"],
        "net_out": ["mean", "max", "min"],
    }
)
df_hourly.columns = ["_".join(col).strip() for col in df_hourly.columns.values]
df_hourly.reset_index(inplace=True)


# ============================
# 為每個指標創建單獨的sheet（ds:日期，y:值）
# ============================
# CPU sheet
df_cpu = pd.DataFrame({
    "ds": rng,
    "y": cpu
})

# Memory sheet
df_memory = pd.DataFrame({
    "ds": rng,
    "y": memory_used
})

# Disk sheet
df_disk = pd.DataFrame({
    "ds": rng,
    "y": disk_used
})

# Network In sheet
df_net_in = pd.DataFrame({
    "ds": rng,
    "y": net_in
})

# Network Out sheet
df_net_out = pd.DataFrame({
    "ds": rng,
    "y": net_out
})

# ============================
# 導出到 Excel
# ============================
output_file = "server_metrics_2025_08.xlsx"
with pd.ExcelWriter(output_file, engine="openpyxl") as writer:
    df_aug.to_excel(writer, index=False, sheet_name="10min_data")
    df_hourly.to_excel(writer, index=False, sheet_name="hourly_stats")
    # 添加各個指標的單獨sheet
    df_cpu.to_excel(writer, index=False, sheet_name="cpu")
    df_memory.to_excel(writer, index=False, sheet_name="memory")
    df_disk.to_excel(writer, index=False, sheet_name="disk")
    df_net_in.to_excel(writer, index=False, sheet_name="net_in")
    df_net_out.to_excel(writer, index=False, sheet_name="net_out")

print(f"? 數據已生成并導出到 {output_file}")

python history_data.py

cd /forecast
# 直接編輯，在保存時會生成文件
vim train_model.py

from neuralprophet import NeuralProphet
import pandas as pd
import warnings
from neuralprophet import save

# 忽略警告
warnings.filterwarnings('ignore')

# 1. 讀取Excel數據
excel_path = 'server_metrics_2025_08.xlsx'
sheet_name = 'cpu'
# sheet_name = 'memory'
# sheet_name = 'disk'
# sheet_name = 'net_in'
# sheet_name = 'net_out'
df = pd.read_excel(excel_path, sheet_name=sheet_name)

# 只保留 ds 和 y 列
df = df[['ds', 'y']]

# 2. 初始化并訓練模型
m = NeuralProphet(
    changepoints_range=0.8,         # 只在前80%歷史數據中尋找變點，避免對最新數據過擬合
    trend_reg=1,                    # 適度正則化，防止趨勢過度擬合 
    seasonality_reg=0.5,            # 適度正則化，防止季節性過擬合
    n_lags=144,                     # n_lags越大，可用訓練樣本越少
    ar_reg=0.7,                     # 輕微正則化自回歸系數，防止過擬合
    n_forecasts=6,                  # 預測的步數，10分數間隔的數據生成6條
    collect_metrics={ "MAE": "MeanAbsoluteError", "MAPE": "MeanAbsolutePercentageError" },
)

# 3. 分割訓練集和驗證集
df_train, df_val = m.split_df(df, valid_p=0.2)

# 4. 訓練模型
m.fit(df_train, validation_df=df_val, freq="10min")

# 5. 保存模型到本地目錄
save(m, sheet_name + ".np")

cd /forecast
# 直接編輯，在保存時會生成文件
vim app.py

import streamlit as st
import pandas as pd
import plotly.graph_objects as go
from neuralprophet import load
import warnings
import numpy as np
from datetime import datetime, timedelta
import sys


def generate_forecast(df, sheet_name):
    """
    生成預測的獨立函數
    按步數遍歷，步數1取yhat1，步數2取yhat2...
    所有預測值都放到yhat1列中
    """
    try:
        # 在預測函數中僅保留'ds'和'y'列用于模型訓練
        model_df = df[['ds', 'y']].copy()
        
        # 加載預訓練模型
        model_path = f"{sheet_name}.np"
        
        model = load(model_path)
        
        # 生成預測
        future_df = model.make_future_dataframe(model_df, n_historic_predictions=False)
        forecast_result = model.predict(future_df, decompose=False)

        print(forecast_result)

        # 獲取最后一個數據點
        last_data_point = model_df['ds'].max()

        # 處理預測結果
        forecast_long = []
        last_actual_idx = forecast_result['y'].last_valid_index() if 'y' in forecast_result.columns else -1
        start_idx = last_actual_idx + 1 if last_actual_idx + 1 < len(forecast_result) else 0

        # 生成預測步驟，按步數取對應yhat，統一放到yhat1列
        for step in range(1, FORECAST_STEPS + 1):
            yhat_col = f'yhat{step}'  # 步數1取yhat1，步數2取yhat2...
            
            current_idx = start_idx + (step - 1)
            if current_idx >= len(forecast_result):
                current_idx = len(forecast_result) - 1
                st.warning(f"預測數據不足，使用最后一條數據預測第{step}步")
            
            if current_idx < len(forecast_result):
                date = forecast_result.loc[current_idx, 'ds']
                
                if pd.notna(date) and yhat_col in forecast_result.columns and pd.notna(forecast_result.loc[current_idx, yhat_col]):
                    forecast_time = last_data_point + step * FORCE_TIME_INTERVAL
                    # 所有預測值都放到yhat1列
                    forecast_entry = {
                        'ds': forecast_time,
                        'yhat1': forecast_result.loc[current_idx, yhat_col],
                        'step': step
                    }
                    forecast_long.append(forecast_entry)
                else:
                    st.warning(f"第{step}步預測值缺失，使用歷史平均值")
                    forecast_time = last_data_point + step * FORCE_TIME_INTERVAL
                    avg_value = model_df['y'].mean()
                    forecast_entry = {
                        'ds': forecast_time,
                        'yhat1': avg_value,
                        'step': step
                    }
                    forecast_long.append(forecast_entry)
            else:
                forecast_time = last_data_point + step * FORCE_TIME_INTERVAL
                avg_value = model_df['y'].mean()
                forecast_entry = {
                    'ds': forecast_time,
                    'yhat1': avg_value,
                    'step': step
                }
                forecast_long.append(forecast_entry)

        # 轉換為DataFrame
        forecast_long = pd.DataFrame(forecast_long)
        forecast_merged = forecast_long.merge(df[['ds', 'y']], on='ds', how='left')
        
        return forecast_merged
        
    except Exception as e:
        st.error(f"預測出錯: {str(e)}")
        st.info("可能的原因：模型文件不存在、數據格式不正確或模型訓練不完整")
        return None

streamlit run app.py

# python-dotenv：可以使用load_dotenv從同目錄的.env文件中讀取配置
pip install python-dotenv openai

DEEPSEEK_API_KEY=sk-*********

import os
from pathlib import Path

# 項目根目錄
ROOT_DIR = Path(__file__).parent

# Excel文件路徑
EXCEL_PATH = os.path.join(ROOT_DIR, 'server_metrics_2025_08.xlsx')

# 資源類型列表
RESOURCE_TYPES = ['cpu', 'memory', 'disk', 'net_in', 'net_out']

# 資源類型中文映射
RESOURCE_TYPE_MAP = {
    'cpu': 'CPU使用率',
    'memory': '內存使用率',
    'disk': '磁盤使用率',
    'net_in': '網絡入流量',
    'net_out': '網絡出流量'
}

# 時間格式
DATETIME_FORMAT = '%Y-%m-%d %H:%M:%S'
DATE_FORMAT = '%Y-%m-%d'

import logging
import os
from datetime import datetime
from pathlib import Path

# 創建logs目錄
log_dir = Path(__file__).parent / 'logs'
log_dir.mkdir(exist_ok=True)

# 配置日志格式
log_format = '%(asctime)s - %(levelname)s - %(message)s'
date_format = '%Y-%m-%d %H:%M:%S'

# 創建日志文件名（包含日期）
log_file = log_dir / f'chat_app_{datetime.now().strftime("%Y%m%d")}.log'

# 配置日志
logging.basicConfig(
    level=logging.INFO,
    format=log_format,
    datefmt=date_format,
    handlers=[
        logging.FileHandler(log_file, encoding='utf-8'),
        logging.StreamHandler()
    ]
)

# 創建logger實例
logger = logging.getLogger(__name__)

def initialize_openai_client():
    """初始化OpenAI客戶端
    
    功能：
    - 從環境變量獲取API密鑰
    - 初始化DeepSeek API客戶端
    - 配置API基礎URL
    
    返回：
    - OpenAI客戶端實例 或 None（如果初始化失?。?    """
    # 從環境變量獲取API密鑰
    api_key = os.getenv('DEEPSEEK_API_KEY')
    if not api_key:
        st.error("未找到DEEPSEEK_API_KEY環境變量")
        return None
    
    # 創建并返回配置好的客戶端實例
    return OpenAI(
        api_key=api_key,
        base_url="https://api.deepseek.com/v1"  # DeepSeek API的基礎URL
    )

def generate_prompt(start_dt, end_dt, resource_type=None):
    """生成提示詞：支持時間點或時間范圍。
    - 當 start_dt == end_dt 時，生成“在 X 時 ...”的時間點提示
    - 當不相等時，生成“在 X 至 Y 這段時間 ...”的時間范圍提示
    """
    if not start_dt or not end_dt:
        return ""

    start_str = start_dt.strftime("%Y-%m-%d %H:%M:%S")
    end_str = end_dt.strftime("%Y-%m-%d %H:%M:%S")

    resource_name = RESOURCE_TYPE_MAP.get(resource_type, resource_type) if resource_type else None

    if start_dt == end_dt:
        if resource_name:
            return f"在{start_str} 時服務器的{resource_name}情況如何？請進行分析，指出異常與風險。"
        return f"在{start_str} 時服務器的整體運行情況如何？請進行分析，指出異常與風險。"
    else:
        if resource_name:
            return f"在{start_str} 至 {end_str} 這段時間內，服務器的{resource_name}情況如何？請進行分析，指出異常與風險。"
        return f"在{start_str} 至 {end_str} 這段時間內，服務器的整體運行情況如何？請進行分析，指出異常與風險。"

def filter_data(df, date, time=None, resource_type=None, end_date=None, end_time=None):
    """根據選擇的日期時間范圍和資源類型篩選數據"""
    if df is None:
        logger.warning("輸入的DataFrame為空")
        return None
    
    logger.info(f"開始篩選數據，起始日期：{date}, 起始時間：{time or '00:00:00'}")
    logger.info(f"結束日期：{end_date or date}, 結束時間：{end_time or '23:59:59'}")
    logger.info(f"資源類型：{resource_type or '所有資源'}")
    
    # 構建開始日期時間
    start_datetime = pd.Timestamp.combine(date, time) if time else pd.Timestamp.combine(date, pd.Timestamp.min.time())
    
    # 構建結束日期時間
    if end_date and end_time:
        end_datetime = pd.Timestamp.combine(end_date, end_time)
    elif end_date:
        end_datetime = pd.Timestamp.combine(end_date, pd.Timestamp.max.time())
    else:
        end_datetime = pd.Timestamp.combine(date, pd.Timestamp.max.time())
    
    logger.info(f"篩選時間范圍：{start_datetime} 至 {end_datetime}")
    
    # 篩選時間范圍內的數據
    filtered_df = df[(df['ds'] >= start_datetime) & (df['ds'] <= end_datetime)]
    
    # 記錄篩選結果
    logger.info(f"時間范圍內的數據條數：{len(filtered_df)}")
    
    # 如果選擇了資源類型，只返回相關列
    if resource_type and resource_type in df.columns:
        filtered_df = filtered_df[['ds', resource_type]]
        logger.info(f"已篩選資源類型：{resource_type}")
    
    # 記錄最終結果
    logger.info(f"最終篩選結果數據條數：{len(filtered_df)}")
    if not filtered_df.empty:
        logger.info(f"數據時間范圍：{filtered_df['ds'].min()} 至 {filtered_df['ds'].max()}")
        if resource_type:
            stats = filtered_df[resource_type].describe()
            logger.info(f"資源統計信息：\n{stats}")
    else:
        logger.warning("篩選結果為空")
    
    return filtered_df

streamlit run chat_app.py