📝 Update Random Forest and K-Means documentation with new content and visualizations

- Enhanced the Random Forest section with detailed explanations of decision tree generation and classification processes, including handling of outliers.
- Added a new section on Gradient Boosting, explaining its principles, working mechanism, and providing code examples.
- Updated K-Means documentation to include an interactive animation for better visualization of the clustering process, along with a new section on DBSCAN, detailing its algorithm and applications.
- Improved overall clarity and structure of the documentation to facilitate understanding of clustering algorithms.

Author: jiangyangcreate

docs/docs/机器学习/传统算法/K均值算法.md

@@ -46,9 +46,19 @@ $
 
 以此类推
 
+### 动画演示
+
+下面的动画使用10*10的网格模拟图片，通过修改网格颜色表示分类。
+
+通过绿色表示样本分类1，深绿色表示其簇中心点，蓝色表示样本分类2，深蓝色表示其簇中心点。
+
+初始簇中心点1在左上角，簇中心点2在中间。
+
+每次迭代停顿5秒。
+
 <details>
 <summary>点击查看动画</summary>
-``` jsx live
+``` jsx live 
 function KMeansAnimation() {
   const gridSize = 10;
 
@@ -59,6 +69,7 @@ function KMeansAnimation() {
   ]);
   const [step, setStep] = React.useState(0);
   const [iteration, setIteration] = React.useState(0);
+  const [ready, setReady] = React.useState(false);
 
   React.useEffect(() => {
     const generateAllGridPoints = () => {
@@ -76,14 +87,21 @@ function KMeansAnimation() {
     };
 
     setDataPoints(generateAllGridPoints());
+    
+    // 初始化后等待5秒再开始第一次迭代
+    const initialTimer = setTimeout(() => {
+      setReady(true);
+    }, 5000);
+    
+    return () => clearTimeout(initialTimer);
   }, []);
 
   const distance = (point1, point2) => {
     return Math.sqrt(Math.pow(point1.x - point2.x, 2) + Math.pow(point1.y - point2.y, 2));
   };
 
   React.useEffect(() => {
-    if (dataPoints.length === 0) return;
+    if (dataPoints.length === 0 || !ready) return;
 
     const timer = setTimeout(() => {
       if (step === 0) {
@@ -116,11 +134,17 @@ function KMeansAnimation() {
 
         setStep(0);
         setIteration(prev => prev + 1);
+        
+        // 每次迭代完成后暂停5秒
+        setReady(false);
+        setTimeout(() => {
+          setReady(true);
+        }, 5000);
       }
     }, 1000);
 
     return () => clearTimeout(timer);
-  }, [step, dataPoints, centroids]);
+  }, [step, dataPoints, centroids, ready]);
 
   const renderGrid = () => {
     const grid = [];
@@ -167,7 +191,10 @@ function KMeansAnimation() {
   return (
     <div style={{display: 'flex', flexDirection: 'column', alignItems: 'center', padding: '16px'}}>
       <h2 style={{fontSize: '1.25rem', fontWeight: 'bold', marginBottom: '16px'}}>K-Means 聚类算法可视化</h2>
-      <div style={{marginBottom: '16px'}}>迭代次数: {iteration}</div>
+      <div style={{marginBottom: '16px'}}>
+        迭代次数: {iteration}
+        {!ready && <span style={{marginLeft: '10px', color: '#718096'}}>等待中...</span>}
+      </div>
       <div style={{
         display: 'grid',
         gridTemplateColumns: 'repeat(10, 1fr)',
@@ -197,8 +224,6 @@ function KMeansAnimation() {
     </div>
   );
 }
-
-export default KMeansAnimation;
 ```
 </details>
 
@@ -380,3 +405,22 @@ plt.title('Quantized image (64 colors, Random)')
 plt.imshow(recreate_image(codebook_random, labels_random, w, h))
 
 ```
+
+### DBscan
+
+[DBSCAN (Density-Based Spatial Clustering of Applications with Noise) ](https://scikit-learn.org/stable/modules/generated/sklearn.cluster.DBSCAN.html#)
+
+是一种流行的密度聚类算法。它的主要特点是：
+
+1. 基于密度的聚类方法，能够发现任意形状的聚类
+2. 不需要预先指定聚类数量
+3. 能够识别噪声点
+4. 通过两个参数控制：邻域半径ε和最小点数MinPts
+
+DBSCAN的基本原理是找出密度连接的区域，形成聚类。它将数据点分为三类：
+- 核心点：在其ε-邻域内至少有MinPts个点
+- 边界点：在某个核心点的ε-邻域内，但其自身ε-邻域内的点数少于MinPts
+- 噪声点：既不是核心点也不是边界点的点
+
+DBSCAN算法特别适合处理包含噪声和形状不规则聚类的数据集，广泛应用于空间数据库、地理信息系统、图像处理等领域。
+

docs/docs/机器学习/传统算法/随机森林.md

@@ -7,20 +7,22 @@ title: 随机森林
 
 随机森林是对决策树集合的特有名称。
 
-随机森林里我们有多个决策树（所以叫“森林”）。
+随机森林里我们有多个决策树（所以叫"森林"）。
 
-为了给一个新的观察值分类，根据它的特征，每一个决策树都会给出一个分类。
+传统决策树很容易受到个别异常数据的影响构造出奇怪的树，为了避免这种情况，我们假设有100条数据，其中有2条数据异常。
 
-随机森林算法选出投票最多的分类作为分类结果。
-
-怎样生成决策树：
+生成决策树：
 
 1. 如果训练集中有 N 种类别，则有重复地随机选取 N 个样本。这些样本将组成培养决策树的训练集。
 
 2. 如果有 M 个特征变量，那么选取数`m << M`，从而在每个节点上随机选取 m 个特征变量来分割该节点。m 在整个森林养成中保持不变。
 
 3. 每个决策树都最大程度上进行分割，没有剪枝。
 
+- 对于分类问题：每一个决策树都会给出一个分类。随机森林算法选出投票最多的分类作为分类结果。对于这2条数据异常所在的决策树会给出错误结果，正常数据会给出正确的结果，少数服从多数，最终分类正确。
+
+- 对于回归问题：每一个决策树都会给出一个结果，随机森林对不同树取平均。对于这2条数据异常所在的决策树会给出偏差较大的结果，正常数据会给出偏差较小的结果，取平均之后，最终偏差较小。
+
 ```python showLineNumbers
 
 from sklearn.ensemble import RandomForestClassifier
@@ -231,3 +233,180 @@ plt.ylim(-0.05, 1.05)
 
 plt.show()
 ```
+
+### Gradient Boosting
+
+梯度提升（Gradient Boosting）是另一种强大的集成学习方法，与随机森林相似，它也是基于决策树的集成，但构建方式不同。
+
+梯度提升的基本思想是通过迭代地训练一系列弱学习器（通常是浅层决策树），每个新的学习器都试图纠正前面学习器的错误。与随机森林并行建立独立树不同，梯度提升是顺序建立树，每棵树都依赖于之前树的结果。
+
+#### 工作原理
+
+1. 从一个简单的模型（例如只有一个节点的决策树）开始
+2. 计算当前模型的残差（实际值与预测值的差）
+3. 训练一个新的弱学习器来预测这些残差
+4. 将新学习器添加到模型中（通常乘以一个学习率）
+5. 重复步骤2-4，直到达到指定的迭代次数或误差不再显著减少
+
+:::info
+
+什么是残差？
+
+假设我们有一个简单的回归问题：
+真实值：[10, 20, 30, 40]
+
+第一棵树预测结果：[8, 18, 28, 38]
+则残差为**真实值**-**第一棵树预测结果**
+[2, 2, 2, 2]
+
+第二棵树会尝试预测这个残差[2, 2, 2, 2]
+
+如果第二棵树预测结果为[1.8, 1.8, 1.8, 1.8]
+
+则新的残差为：[0.2, 0.2, 0.2, 0.2]
+
+最终预测 = 第一棵树预测 + 第二棵树预测 = [9.8, 19.8, 29.8, 39.8]
+
+最终预测更加接近真实值，损失更小。
+:::
+
+#### 简单代码示例
+
+```python showLineNumbers
+from sklearn.ensemble import GradientBoostingClassifier
+import numpy as np
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+# 创建数据集
+X, y = make_classification(n_samples=1000, n_features=10, n_informative=5, 
+                          n_redundant=2, random_state=42)
+
+# 分割数据集
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 创建梯度提升模型
+'''
+主要参数说明：
+n_estimators: 弱学习器的数量
+learning_rate: 学习率，控制每个弱学习器的贡献
+max_depth: 决策树的最大深度
+subsample: 用于拟合基学习器的样本比例，<1.0表示采用随机梯度提升
+'''
+gbm = GradientBoostingClassifier(n_estimators=100, 
+                                learning_rate=0.1, 
+                                max_depth=3, 
+                                subsample=0.8,
+                                random_state=42)
+
+# 训练模型
+gbm.fit(X_train, y_train)
+
+# 评估模型
+accuracy = gbm.score(X_test, y_test)
+print(f"模型准确率: {accuracy:.4f}")
+
+# 进行预测
+y_pred = gbm.predict(X_test)
+y_proba = gbm.predict_proba(X_test)
+```
+
+#### XGBoost
+
+XGBoost（eXtreme Gradient Boosting）是梯度提升的高效实现，具有以下优势：
+
+- 加入了正则化项防止过拟合
+- 支持并行计算
+- 可以处理缺失值
+- 内置交叉验证
+- 提供树剪枝机制
+
+```python showLineNumbers
+import xgboost as xgb
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+
+# 创建数据集
+X, y = make_classification(n_samples=1000, n_features=10, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 创建DMatrix对象（XGBoost的数据格式）
+dtrain = xgb.DMatrix(X_train, label=y_train)
+dtest = xgb.DMatrix(X_test, label=y_test)
+
+# 设置参数
+params = {
+    'objective': 'binary:logistic',  # 目标函数
+    'max_depth': 3,                  # 树的最大深度
+    'eta': 0.1,                      # 学习率
+    'subsample': 0.8,                # 样本采样比例
+    'colsample_bytree': 0.8,         # 特征采样比例
+    'eval_metric': 'logloss'         # 评估指标
+}
+
+# 训练模型
+num_rounds = 100
+model = xgb.train(params, dtrain, num_rounds)
+
+# 预测
+preds = model.predict(dtest)
+pred_labels = [1 if p > 0.5 else 0 for p in preds]
+accuracy = sum(pred_labels == y_test) / len(y_test)
+print(f"XGBoost模型准确率: {accuracy:.4f}")
+```
+
+#### LightGBM
+
+LightGBM是另一种高效的梯度提升实现，专注于提高训练速度和内存效率：
+
+- 使用基于直方图的算法加速训练
+- 采用叶子优先的生长策略
+- 支持类别特征的直接处理
+- 对大规模数据和高维特征友好
+
+```python showLineNumbers
+import lightgbm as lgb
+from sklearn.datasets import make_classification
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+
+# 创建数据集
+X, y = make_classification(n_samples=1000, n_features=10, random_state=42)
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# 创建数据集格式
+train_data = lgb.Dataset(X_train, label=y_train)
+
+# 设置参数
+params = {
+    'objective': 'binary',         # 目标函数
+    'metric': 'binary_logloss',    # 评估指标
+    'max_depth': 3,                # 树的最大深度
+    'learning_rate': 0.1,          # 学习率
+    'feature_fraction': 0.8,       # 特征采样比例
+    'bagging_fraction': 0.8,       # 样本采样比例
+    'bagging_freq': 5              # 样本采样频率
+}
+
+# 训练模型
+num_rounds = 100
+model = lgb.train(params, train_data, num_rounds)
+
+# 预测
+y_pred_proba = model.predict(X_test)
+y_pred = [1 if p > 0.5 else 0 for p in y_pred_proba]
+accuracy = accuracy_score(y_test, y_pred)
+print(f"LightGBM模型准确率: {accuracy:.4f}")
+```
+
+#### 梯度提升与随机森林的比较
+
+| 特性 | 梯度提升 | 随机森林 |
+|------|----------|----------|
+| 训练方式 | 顺序（每棵树依赖前面的树） | 并行（树独立训练） |
+| 对过拟合的敏感性 | 较高 | 较低 |
+| 参数调优难度 | 较高 | 较低 |
+| 处理大型数据集 | 可能较慢 | 较快（可并行） |
+| 预测性能 | 通常更高（合理调参后） | 很好但通常低于梯度提升 |
+| 模型解释性 | 较低 | 中等 |
+| 对异常值的敏感性 | 较高 | 较低 |