glow

Hello World - 博客开张了！🎉

2026-05-01T02:00:00.000Z

你好，世界！

欢迎来到我的博客！这里是我记录技术学习、生活思考的地方。

为什么要建博客？

写作是最好的学习方式。

建博客的初衷很简单——想有一个地方能够：

记录学习过程：把学到的东西用自己的语言整理出来，加深理解
分享知识：如果我的笔记能帮助到别人，那再好不过了
建立个人知识库：随时回顾，随时查阅

技术栈

这个博客基于 Hexo 构建，使用 Butterfly 主题，部署在 GitHub Pages 上。

# 本地预览
hexo server

# 生成静态文件
hexo generate

# 部署
hexo deploy

接下来

我会在这里分享：

🤖 AI / 机器学习笔记
📊 算法与数据结构
💡 编程技巧与心得
📖 读书笔记

希望这里能成为你喜欢的技术角落！

Never forget nor regret. ⭐

深度学习入门笔记：从感知机到神经网络

2026-04-20T06:30:00.000Z

深度学习基础：感知机与神经网络

本文是深度学习系列笔记的第一篇，涵盖感知机模型、激活函数与反向传播算法。

1. 感知机（Perceptron）

感知机是最简单的神经元模型，由 Rosenblatt 在 1958 年提出。

给定输入向量 $\mathbf{x} = (x_1, x_2, \ldots, x_n)$ 和权重向量 $\mathbf{w}$，感知机输出：

$$y = f\left(\sum_{i=1}^n w_i x_i + b\right)$$

其中 $f$ 是激活函数，$b$ 是偏置项。

2. 常见激活函数

函数	公式	特点
Sigmoid	$\sigma(x) = \frac{1}{1+e^{-x}}$	输出范围 (0,1)，梯度消失
ReLU	$f(x) = \max(0, x)$	计算高效，不饱和
Tanh	$f(x) = \tanh(x)$	输出范围 (-1,1)

3. 多层感知机（MLP）

多层感知机由输入层、若干隐藏层和输出层组成：

import torch
import torch.nn as nn

class MLP(nn.Module):
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.layers = nn.Sequential(
            nn.Linear(input_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, hidden_dim),
            nn.ReLU(),
            nn.Linear(hidden_dim, output_dim)
        )
    
    def forward(self, x):
        return self.layers(x)

4. 反向传播算法

反向传播（Backpropagation）利用链式法则计算梯度：

$$\frac{\partial L}{\partial w_i} = \frac{\partial L}{\partial y} \cdot \frac{\partial y}{\partial w_i}$$

小结

感知机是神经网络的基础单元
激活函数引入非线性，使网络能拟合复杂函数
反向传播是训练神经网络的核心算法

下一篇：卷积神经网络（CNN）原理

参考资料：《深度学习》- Goodfellow et al.

算法模板：常用数据结构与算法整理

2026-04-15T01:00:00.000Z

算法竞赛模板整理

整理了竞赛中常用的算法模板，方便快速查阅。

排序算法

快速排序

void quickSort(vector<int>& arr, int l, int r) {
    if (l >= r) return;
    int pivot = arr[(l + r) / 2];
    int i = l - 1, j = r + 1;
    while (i < j) {
        do i++; while (arr[i] < pivot);
        do j--; while (arr[j] > pivot);
        if (i < j) swap(arr[i], arr[j]);
    }
    quickSort(arr, l, j);
    quickSort(arr, j + 1, r);
}

图论

最短路（Dijkstra）

vector<int> dijkstra(int src, vectorint,int>>>& adj, int n) {
    vector<int> dist(n, INT_MAX);
    priority_queueint,int>, vectorint,int>>, greater<>> pq;
    dist[src] = 0;
    pq.push({0, src});
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (d > dist[u]) continue;
        for (auto [v, w] : adj[u]) {
            if (dist[u] + w < dist[v]) {
                dist[v] = dist[u] + w;
                pq.push({dist[v], v});
            }
        }
    }
    return dist;
}

动态规划

最长公共子序列（LCS）

int lcs(string& a, string& b) {
    int m = a.size(), n = b.size();
    vectorint>> dp(m+1, vector<int>(n+1, 0));
    for (int i = 1; i <= m; i++)
        for (int j = 1; j <= n; j++)
            dp[i][j] = (a[i-1] == b[j-1]) ? dp[i-1][j-1] + 1
                                            : max(dp[i-1][j], dp[i][j-1]);
    return dp[m][n];
}

持续更新中… 🔄