import numpy as np
import matplotlib.pyplot as plt

# 生成模拟数据
np.random.seed(42)
X = 2 * np.random.rand(100, 1)
y = 4 + 3 * X + np.random.randn(100, 1)

# 梯度下降参数
learning_rate = 0.01
n_iterations = 1000
m = len(X)  # 样本数量

# 初始化参数
w = np.random.randn(2, 1)
X_b = np.c_[np.ones((m, 1)), X]

# 梯度下降训练
for iteration in range(n_iterations):
    gradients = 2/m * X_b.T.dot(X_b.dot(w) - y)
    w = w - learning_rate * gradients

# 预测
X_new = np.array([[0], [2]])
X_new_b = np.c_[np.ones((2, 1)), X_new]
y_predict = X_new_b.dot(w)

# 可视化
plt.scatter(X, y, alpha=0.6, label='真实数据')
plt.plot(X_new, y_predict, 'r-', linewidth=2, label='预测直线')
plt.legend()
plt.show()

from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier, plot_tree
import matplotlib.pyplot as plt

# 加载 Iris 数据集
iris = load_iris()
X = iris.data
y = iris.target

# 创建决策树分类器
dt_clf = DecisionTreeClassifier(max_depth=3, random_state=42)
dt_clf.fit(X, y)

# 可视化决策树
plt.figure(figsize=(20, 10))
plot_tree(dt_clf,
          feature_names=iris.feature_names,
          class_names=iris.target_names,
          filled=True,
          rounded=True)
plt.show()

# 预测
sample = [[5.0, 3.4, 1.5, 0.2]]
prediction = dt_clf.predict(sample)
print(f"预测类别: {iris.target_names[prediction[0]]}")

from sklearn.svm import SVC
from sklearn.datasets import make_moons
import matplotlib.pyplot as plt

# 生成非线性数据
X, y = make_moons(n_samples=100, noise=0.1, random_state=42)

# 创建 SVM 分类器（RBF 核）
svm_clf = SVC(kernel='rbf', gamma='scale', C=1.0)
svm_clf.fit(X, y)

# 可视化决策边界
plt.figure(figsize=(10, 6))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap='coolwarm', s=50)
ax = plt.gca()
xlim = ax.get_xlim()
ylim = ax.get_ylim()
xx, yy = np.meshgrid(np.linspace(xlim[0], xlim[1], 100),
                     np.linspace(ylim[0], ylim[1], 100))
Z = svm_clf.decision_function(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)
plt.contourf(xx, yy, Z, alpha=0.3, cmap='coolwarm')
plt.contour(xx, yy, Z, colors='k', levels=[-1, 0, 1],
           linestyles=['--', '-', '--'])
plt.show()

from sklearn.cluster import KMeans
from sklearn.datasets import make_blobs
import matplotlib.pyplot as plt

# 生成聚类数据
X, y_true = make_blobs(n_samples=300, centers=4,
                        cluster_std=0.6, random_state=42)

# 创建 K-means 聚类器
kmeans = KMeans(n_clusters=4, random_state=42, n_init=10)
y_pred = kmeans.fit_predict(X)

# 可视化结果
plt.figure(figsize=(12, 5))

# 左图：聚类结果
plt.subplot(1, 2, 1)
plt.scatter(X[:, 0], X[:, 1], c=y_pred, cmap='viridis', s=50, alpha=0.7)
plt.scatter(kmeans.cluster_centers_[:, 0],
           kmeans.cluster_centers_[:, 1],
           c='red', marker='X', s=200, label='质心')
plt.title('K-means 聚类结果')
plt.legend()

# 右图：肘部法则确定 K 值
plt.subplot(1, 2, 2)
wcss = []
K_range = range(1, 11)
for k in K_range:
    kmeans_temp = KMeans(n_clusters=k, random_state=42, n_init=10)
    kmeans_temp.fit(X)
    wcss.append(kmeans_temp.inertia_)

plt.plot(K_range, wcss, 'bo-')
plt.xlabel('聚类数量 K')
plt.ylabel('WCSS（簇内平方和）')
plt.title('肘部法则确定最优 K 值')
plt.show()

from sklearn.naive_bayes import GaussianNB
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix

# 加载数据
iris = load_iris()
X_train, X_test, y_train, y_test = train_test_split(
    iris.data, iris.target, test_size=0.3, random_state=42)

# 创建朴素贝叶斯分类器
nb_clf = GaussianNB()
nb_clf.fit(X_train, y_train)

# 预测与评估
y_pred = nb_clf.predict(X_test)
print("混淆矩阵:")
print(confusion_matrix(y_test, y_pred))
print("\n分类报告:")
print(classification_report(y_test, y_pred,
                          target_names=iris.target_names))

# 1. 克隆项目
git clone https://github.com/datawhalechina/simple-ml-code.git

# 2. 进入目录
cd simple-ml-code

# 3. 安装依赖
pip install numpy pandas matplotlib scikit-learn seaborn

# 或者一键安装
pip install -r requirements.txt

# 4. 开始学习第一章
python docs/chapter1/线性回归.py

import pandas as pd
from sklearn.preprocessing import StandardScaler, MinMaxScaler

# 读取数据
df = pd.read_csv('data.csv')

# 缺失值处理
df.fillna(df.mean(), inplace=True)  # 用均值填充
# 或 df.dropna()  # 删除缺失行

# 标准化（Z-score）
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)

# 归一化（Min-Max）
minmax_scaler = MinMaxScaler()
X_normalized = minmax_scaler.fit_transform(X)

from sklearn.model_selection import cross_val_score
from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score

# 交叉验证
cv_scores = cross_val_score(clf, X, y, cv=5, scoring='accuracy')
print(f"交叉验证准确率: {cv_scores.mean():.3f} (+/- {cv_scores.std():.3f})")

# 详细评估指标
y_pred = clf.predict(X_test)
print(f"准确率 (Accuracy): {accuracy_score(y_test, y_pred):.3f}")
print(f"精确率 (Precision): {precision_score(y_test, y_pred, average='weighted'):.3f}")
print(f"召回率 (Recall): {recall_score(y_test, y_pred, average='weighted'):.3f}")
print(f"F1 分数: {f1_score(y_test, y_pred, average='weighted'):.3f}")

from sklearn.model_selection import GridSearchCV

# 定义参数网格
param_grid = {
    'n_estimators': [50, 100, 200],
    'max_depth': [3, 5, 7, None],
    'min_samples_split': [2, 5, 10]
}

# 网格搜索
grid_search = GridSearchCV(clf, param_grid, cv=5, scoring='accuracy')
grid_search.fit(X_train, y_train)

print(f"最优参数: {grid_search.best_params_}")
print(f"最优分数: {grid_search.best_score_:.3f}")

# 预剪枝
dt_clf = DecisionTreeClassifier(max_depth=5, min_samples_split=10)

# 后剪枝（成本复杂度剪枝）
path = dt_clf.cost_complexity_pruning_path(X_train, y_train)
ccp_alphas, impurities = path.ccp_alphas, path.impurities
clf = DecisionTreeClassifier(random_state=42, ccp_alpha=ccp_alphas[10])

kmeans = KMeans(n_clusters=K, n_init=10, random_state=42)

kmeans = KMeans(n_clusters=K, init='k-means++', n_init=10)