import numpy as np
import matplotlib.pyplot as plt

# 生成帶噪聲的線性數據
np.random.seed(42)
X = 2 * np.random.rand(100, 1)  # 特徵：100個樣本，範圍[0,2)
y = 4 + 3 * X + np.random.randn(100, 1)  # 真實關係：y=4+3x+噪聲

# 繪製散點圖
plt.scatter(X, y, alpha=0.6)
plt.xlabel("房子面積 (百平方米)")
plt.ylabel("房價 (萬元)")
plt.title("房價與面積的關係")
plt.show()

import numpy as np
import matplotlib.pyplot as plt

# 示例數據
x = np.array([1, 2, 3, 4, 5])
y = np.array([2, 4, 5, 4, 6])

# 計算最佳擬合直線
def ordinary_least_squares(x, y):
    """普通最小二乘法"""
    n = len(x)
    w = (n * np.sum(x*y) - np.sum(x) * np.sum(y)) / (n * np.sum(x**2) - np.sum(x)**2)
    b = (np.sum(y) - w * np.sum(x)) / n
    return w, b

w_opt, b_opt = ordinary_least_squares(x, y)
print(f"最優參數: w = {w_opt:.3f}, b = {b_opt:.3f}")

# 可視化
plt.figure(figsize=(10, 6))
plt.scatter(x, y, color='blue', s=100, label='數據點', zorder=5)

# 繪製擬合直線
x_line = np.linspace(0, 6, 100)
y_line = w_opt * x_line + b_opt
plt.plot(x_line, y_line, 'red', linewidth=2, label=f'擬合直線: y = {w_opt:.2f}x + {b_opt:.2f}')

# 繪製誤差線（殘差）
for i in range(len(x)):
    y_pred = w_opt * x[i] + b_opt
    plt.plot([x[i], x[i]], [y[i], y_pred], 'green', linestyle='--', alpha=0.7)
    plt.text(x[i], (y[i] + y_pred)/2, f'e{i+1}', ha='right', va='center')

plt.xlabel('x')
plt.ylabel('y')
plt.title('最小二乘法幾何解釋：最小化垂直距離的平方和')
plt.legend()
plt.grid(True, alpha=0.3)
plt.show()

def least_squares_derivation(x, y):
    """最小二乘法的完整推導"""
    n = len(x)
    x_mean = np.mean(x)
    y_mean = np.mean(y)
    
    # 計算分子和分母
    numerator = np.sum((x - x_mean) * (y - y_mean))
    denominator = np.sum((x - x_mean) ** 2)
    
    # 計算最優參數
    w_opt = numerator / denominator
    b_opt = y_mean - w_opt * x_mean
    
    # 計算損失函數值
    y_pred = w_opt * x + b_opt
    loss = np.sum((y - y_pred) ** 2)
    
    print("=== 最小二乘法推導過程 ===")
    print(f"數據點數量: n = {n}")
    print(f"x的均值: x̄ = {x_mean:.3f}")
    print(f"y的均值: ȳ = {y_mean:.3f}")
    print(f"分子: Σ(xᵢ - x̄)(yᵢ - ȳ) = {numerator:.3f}")
    print(f"分母: Σ(xᵢ - x̄)² = {denominator:.3f}")
    print(f"最優斜率: w = {numerator:.3f} / {denominator:.3f} = {w_opt:.3f}")
    print(f"最優截距: b = {y_mean:.3f} - {w_opt:.3f} × {x_mean:.3f} = {b_opt:.3f}")
    print(f"最小損失值: L = {loss:.3f}")
    
    return w_opt, b_opt, loss

# 應用推導
w, b, min_loss = least_squares_derivation(x, y)

def housing_price_example():
    """房價預測的最小二乘法應用"""
    # 生成模擬房價數據
    np.random.seed(42)
    n_samples = 100
    
    # 房屋面積（平方米）
    area = np.random.normal(100, 30, n_samples)
    # 房價（萬元），真實關係：價格 = 0.8×面積 + 50 + 噪聲
    price = 0.8 * area + 50 + np.random.normal(0, 20, n_samples)
    
    # 使用最小二乘法擬合
    w, b = ordinary_least_squares(area, price)
    
    # 預測新房屋
    new_area = 120  # 120平方米
    predicted_price = w * new_area + b
    
    print("\n=== 房價預測示例 ===")
    print(f"擬合模型: 價格 = {w:.3f}×面積 + {b:.3f}")
    print(f"120平方米房屋預測價格: {predicted_price:.1f}萬元")
    
    # 可視化
    plt.figure(figsize=(12, 5))
    
    plt.subplot(1, 2, 1)
    plt.scatter(area, price, alpha=0.6)
    area_line = np.linspace(area.min(), area.max(), 100)
    price_line = w * area_line + b
    plt.plot(area_line, price_line, 'red', linewidth=2)
    plt.xlabel('房屋面積 (平方米)')
    plt.ylabel('價格 (萬元)')
    plt.title('房價 vs 面積的最小二乘擬合')
    plt.grid(True, alpha=0.3)
    
    plt.subplot(1, 2, 2)
    residuals = price - (w * area + b)
    plt.scatter(area, residuals, alpha=0.6)
    plt.axhline(y=0, color='red', linestyle='--')
    plt.xlabel('房屋面積 (平方米)')
    plt.ylabel('殘差')
    plt.title('殘差分析')
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()
    
    return area, price, w, b

area_data, price_data, w_house, b_house = housing_price_example()

def outlier_sensitivity_demo():
    """展示最小二乘法對異常值的敏感性"""
    # 乾淨數據
    x_clean = np.array([1, 2, 3, 4, 5])
    y_clean = np.array([2, 4, 6, 8, 10])  # 完美線性關係
    
    # 添加異常值
    x_outlier = np.array([1, 2, 3, 4, 5, 6])  # 新增一個點
    y_outlier = np.array([2, 4, 6, 8, 10, 50])  # 最後一個點是異常值
    
    w_clean, b_clean = ordinary_least_squares(x_clean, y_clean)
    w_outlier, b_outlier = ordinary_least_squares(x_outlier, y_outlier)
    
    print("\n=== 異常值敏感性演示 ===")
    print(f"乾淨數據: y = {w_clean:.3f}x + {b_clean:.3f}")
    print(f"含異常值: y = {w_outlier:.3f}x + {b_outlier:.3f}")
    print(f"斜率變化: {abs(w_clean - w_outlier):.3f}")
    
    # 可視化
    plt.figure(figsize=(10, 5))
    
    plt.subplot(1, 2, 1)
    plt.scatter(x_clean, y_clean, label='乾淨數據')
    x_line = np.linspace(0, 7, 100)
    plt.plot(x_line, w_clean*x_line + b_clean, 'blue', label='乾淨數據擬合')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.title('無異常值')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.subplot(1, 2, 2)
    plt.scatter(x_outlier[:-1], y_outlier[:-1], label='正常點')
    plt.scatter(x_outlier[-1], y_outlier[-1], color='red', s=100, label='異常值')
    plt.plot(x_line, w_clean*x_line + b_clean, 'blue', label='真實關係')
    plt.plot(x_line, w_outlier*x_line + b_outlier, 'red', label='受異常值影響')
    plt.xlabel('x')
    plt.ylabel('y')
    plt.title('有異常值')
    plt.legend()
    plt.grid(True, alpha=0.3)
    
    plt.tight_layout()
    plt.show()

outlier_sensitivity_demo()

import numpy as np
import matplotlib.pyplot as plt
import matplotlib.font_manager as fm
from matplotlib.animation import FuncAnimation
import time
import os

# 設置中文字體
plt.rcParams['font.sans-serif'] = ['SimHei']  # 用來正常顯示中文標籤
plt.rcParams['axes.unicode_minus'] = False  # 用來正常顯示負號

# 生成數據
np.random.seed(42)
X = np.linspace(0, 10, 20)
y = 2 * X + 1 + np.random.normal(0, 1.5, 20)

# 初始化參數
w = np.random.randn()
b = np.random.randn()
learning_rate = 0.01

# 創建圖形和軸
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))

# 初始化損失列表
losses = []
max_epochs = 100

# 定義更新函數
def update(epoch):
    global w, b, losses
    
    # 清空圖形
    ax1.clear()
    ax2.clear()
    
    # 計算預測值和損失
    y_pred = w * X + b
    loss = np.mean((y_pred - y) ** 2)
    
    # 計算梯度
    dw = 2 * np.mean((y_pred - y) * X)
    db = 2 * np.mean(y_pred - y)
    
    # 更新參數
    w -= learning_rate * dw
    b -= learning_rate * db
    
    # 繪製第一個圖：數據點和擬合直線
    ax1.scatter(X, y, color='blue', label='真實數據')
    x_line = np.linspace(0, 10, 100)
    y_line = w * x_line + b
    ax1.plot(x_line, y_line, 'r-', linewidth=2, label=f'擬合直線: y = {w:.2f}x + {b:.2f}')
    ax1.set_xlabel('X')
    ax1.set_ylabel('y')
    ax1.set_title(f'線性迴歸擬合 (迭代: {epoch+1})')
    ax1.legend()
    ax1.grid(True)
    
    # 更新損失列表
    losses.append(loss)
    
    # 繪製第二個圖：損失函數下降
    ax2.plot(range(1, len(losses)+1), losses, 'g-', linewidth=2)
    ax2.set_xlabel('迭代次數')
    ax2.set_ylabel('損失值')
    ax2.set_title('損失函數下降')
    ax2.grid(True)
    
    plt.tight_layout()
    
    # 檢查收斂
    if epoch > 10 and abs(losses[-1] - losses[-2]) < 1e-5:
        ani.event_source.stop()
        print(f"模型在 {epoch+1} 輪後收斂!")
    
    return ax1, ax2

# 創建動畫
ani = FuncAnimation(fig, update, frames=range(max_epochs), blit=False, repeat=False, interval=100)

# 保存為GIF
gif_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "線性迴歸動畫.gif")
ani.save(gif_path, writer='pillow', fps=10, dpi=100)

# 顯示最終結果
plt.show()

print(f"最終模型: y = {w:.3f}x + {b:.3f}")
print(f"真實模型: y = 2.000x + 1.000")
print(f"動畫已保存為: {gif_path}")

def gradient_descent_vs_least_squares(x, y, learning_rate=0.01, epochs=1000):
    """比較梯度下降和最小二乘法"""
    # 最小二乘法（解析解）
    w_ls, b_ls = ordinary_least_squares(x, y)
    loss_ls = np.sum((y - (w_ls * x + b_ls)) ** 2)
    
    # 梯度下降（數值解）
    w_gd, b_gd = 0, 0  # 初始值
    n = len(x)
    
    losses = []
    for epoch in range(epochs):
        y_pred = w_gd * x + b_gd
        dw = (-2/n) * np.sum(x * (y - y_pred))
        db = (-2/n) * np.sum(y - y_pred)
        
        w_gd -= learning_rate * dw
        b_gd -= learning_rate * db
        
        loss = np.sum((y - y_pred) ** 2)
        losses.append(loss)
        
        # 檢查收斂
        if epoch > 10 and abs(losses[-1] - losses[-2]) < 1e-8:
            break
    
    print("\n=== 最小二乘法 vs 梯度下降 ===")
    print(f"最小二乘法: w = {w_ls:.6f}, b = {b_ls:.6f}, 損失 = {loss_ls:.6f}")
    print(f"梯度下降:   w = {w_gd:.6f}, b = {b_gd:.6f}, 損失 = {loss:.6f}")
    print(f"參數差異: Δw = {abs(w_ls - w_gd):.6f}, Δb = {abs(b_ls - b_gd):.6f}")
    
    return w_ls, b_ls, w_gd, b_gd, losses

w_ls, b_ls, w_gd, b_gd, loss_history = gradient_descent_vs_least_squares(x, y)

import requests
import json
import pandas as pd

# 模擬一份數據
data = {
    'age': [25, 35, 45, 55, 65, 30, 40, 50, 60, 28], # 年齡
    'annual_income': [40000, 60000, 80000, 100000, 120000, 50000, 70000, 90000, 110000, 45000], # 年收入（美元）
    'credit_limit': [5000, 10000, 15000, 20000, 25000, 8000, 13000, 18000, 23000, 6000] # 信用卡額度（美元）
}
df = pd.DataFrame(data)

# 將數據構建成提示詞
data_string = df.to_string(index=False)

prompt_for_analysis = f"""
你是一名資深數據分析師。請根據我提供的數據，進行多元線性迴歸分析。
數據如下（包含三個字段：年齡(age)、年收入(annual_income)、信用卡額度(credit_limit)）：
{data_string}

請完成以下任務：
1. **分析目標**：以‘age'和’annual_income‘為自變量（特徵），’credit_limit‘為因變量（目標），建立一個多元線性迴歸模型。
2. **模型解讀**：
   - 給出最終得到的迴歸方程。
   - 解釋每個特徵（年齡、年收入）的係數（權重）的實際意義。例如：“年收入每增加1美元，信用卡額度預計增加XX美元。”
   - 分析哪個特徵對預測信用卡額度的貢獻更大？為什麼？
3. **模型評估**：估算模型的R平方值，並解釋其含義。
4. **預測**：請預測一個年齡為30歲、年收入為$55,000的人的信用卡額度大約是多少？

請用清晰、專業的語言彙報你的分析結果。你可以假設數據已經滿足線性迴歸的基本假設。
"""

payload = {
    "model": "qwen-max",
    "input": {
        "messages": [
            {
                "role": "user",
                "content": prompt_for_analysis
            }
        ]
    }
}

response = requests.post(MODEL_ENDPOINT, headers=headers, data=json.dumps(payload))
result = response.json()

analysis_report = result['output']['choices'][0]['message']['content']
print("=== Qwen數據分析報告 ===")
print(analysis_report)