Kalev Yang

Vibe Coding是在创新，还是在制造垃圾

Mon, 01 Jun 2026 15:40:02 GMT

AI 固然好用：从过去需要仔细研究一个功能怎么写，到现在直接告诉 AI 大人我的想法。所有人都在说，AI 让人有了实现自己想法的能力。但问题在于，这种实现往往寄托于有限的 token、短暂的上下文、缺乏深度推演的过程。最终，很多想法成了半成品，甚至是垃圾。

想法到实现
一个想法如何被验证？以前可能靠翻阅资料、动手试错、请教他人。现在，我们更倾向于直接把想法丢给 AI，让它来验证。这种验证太轻了——AI 不会替你去碰撞现实的摩擦力。

主动打破惰性（需要做的事）：

逼自己去想实现的具体步骤——哪怕很笨、很慢。把 AI 当参谋，不当替身。
搜索更多资料去完善想法——AI 给你的摘要永远比不上你自己顺藤摸瓜找到的那篇冷门文章、那组真实数据、那个失败案例。
亲手做一个小到不能再小的原型——写两行代码、画一张草图、列一份清单。让想法和真实世界发生一次摩擦，哪怕只是极小的摩擦。AI 不会替你感受“这一步原来会卡住”。

最后记住：AI 最好的用法，不是替你走路，而是当你已经走在路上时，递给你一张地图。 不把想法交给 AI 就完事，而是把 AI 当成逼自己更清醒的工具。

LeetCode 865 具有所有最深节点的最小子树

Thu, 08 Jan 2026 08:45:50 GMT

题目描述

给定一个根为 root 的二叉树，每个节点的深度是 该节点到根的最短距离 。

返回包含原始树中所有最深节点的 最小子树 。

如果一个节点在 整个树 的任意节点之间具有最大的深度，则该节点是 最深的 。

一个节点的子树是该节点加上它的所有后代的集合。

示例 1

输入：root = [3,5,1,6,2,0,8,null,null,7,4]
输出：[2,7,4]
解释：我们返回值为 2 的节点，在图中用黄色标记。在图中用蓝色标记的是树的最深的节点。注意，节点 5、3 和 2 包含树中最深的节点，但节点 2 的子树最小，因此我们返回它。

思路

考虑到最深的节点可能有多个

首先考虑找到最深的叶子节点，可以用层序遍历找到所有最深的叶子节点
然后从这些最深的叶子节点开始，向上遍历，找到第一个公共祖先，这个公共祖先就是我们要找的最小子树的根节点
最后返回这个公共祖先作为结果

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
        vector<int> fa(501, -1), dleves;
        vector<TreeNode*> mp(501, nullptr);
        queue<TreeNode*> q, tmp;
        q.push(root);
        while (!q.empty()) {
            int sz = q.size();
            dleves.clear();
            while (sz--) {
                TreeNode* p = q.front();
                q.pop();
                dleves.push_back(p->val);
                mp[p->val] = p;
                if (p->left){
                    q.push(p->left);
                    fa[p->left->val] = p->val;
                }
                if (p->right) {
                    q.push(p->right); 
                    fa[p->right->val] = p->val;
                }
            }
        }
        while (true) {
            int anc = dleves[0];
            bool ok = true;
            for (int i = 1; i < dleves.size(); ++i) {
                if (dleves[i] != anc) {
                    ok = false;
                    break;
                }
            }
            if (ok) return mp[anc];

            for (auto& v : dleves) {
                v = fa[v];
            }
        }
        return root;
    }
};

复杂度分析

时间复杂度：O(n)O(n)O(n)，其中 nnn 是二叉树的节点数。需要进行一次层序遍历O(n)O(n)O(n)，以及一次向上跳跃寻找公共祖先的过程O(logn)O(logn)O(logn)。
空间复杂度：O(n)O(n)O(n)，其中 nnn 是二叉树的节点数。需要存储二叉树每个节点的父亲节点，以及层序遍历的队列等等。

优化

这样虽然是很朴素的想法，但实际上不够直接，仔细思考发现：

最深子树的根节点意味着其左右子树的深度相同
答案一定在左子树或右子树中
可以用DFS来解决

代码实现

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    pair<TreeNode*, int> dfs(TreeNode* p) {
        if (!p) return {nullptr, 0};

        auto [l, ln] = dfs(p->left);
        auto [r, rn] = dfs(p->right);
        if (ln > rn) return {l, ln+1};
        if (rn > ln) return {r, rn+1};
        return {p, ln+1}; 
    }
    TreeNode* subtreeWithAllDeepest(TreeNode* root) {
        return dfs(root).first;
    }
};

LeetCode 个人主页

leetcode.cn

kalev - 力扣（LeetCode）

View kalev’s profile on LeetCode, the world’s largest programming community.

https://leetcode.cn/u/kalev/

神经网络实践：Spaceship Titanic预测模型优化笔记

Mon, 24 Nov 2025 16:41:20 GMT

在这篇博客中，我将分享在 Kaggle 的 Spaceship Titanic 竞赛中构建预测模型的完整流程，重点介绍如何通过余弦退火学习率调度器提升模型性能。

竞赛概述

Spaceship Titanic 是 Kaggle 上的一个经典二分类问题，目标是预测乘客是否在宇宙飞船事故中被运输到另一个维度。这是一个典型的结构化数据分类问题，适合初学者入门机器学习。

模型架构与优化策略

核心模型结构

我构建了一个简单的全连接神经网络作为基础模型：

class SpaceshipNN(nn.Module):
    def __init__(self, input_size):
        super(SpaceshipNN, self).__init__()
        self.fc1 = nn.Linear(input_size, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 32)
        self.fc4 = nn.Linear(32, 1)
        self.dropout = nn.Dropout(0.3)
        self.relu = nn.ReLU()
        self.sigmoid = nn.Sigmoid()
    
    def forward(self, x):
        x = self.relu(self.fc1(x))
        x = self.dropout(x)
        x = self.relu(self.fc2(x))
        x = self.dropout(x)
        x = self.relu(self.fc3(x))
        x = self.sigmoid(self.fc4(x))
        return x

关键优化：余弦退火学习率调度

为什么选择余弦退火？传统的学习率调度器如 ReduceLROnPlateau 在验证损失停止改善时降低学习率，但这种方法可能导致训练过早收敛。余弦退火则提供了一种更平滑、周期性的学习率调整方式：

替换传统的 ReduceLROnPlateau 为 CosineAnnealingLR

from torch.optim.lr_scheduler import CosineAnnealingLR

# 初始化优化器
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)

# 初始化余弦退火学习率调度器
scheduler = CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-6)

实现细节

T_max=50：半个周期的 epoch 数
eta_min=1e-6：最小学习率
每个 epoch 后调用 scheduler.step()更新学习率

训练流程优化

def train_with_cosine_annealing(model, train_loader, val_loader, epochs=100):
    for epoch in range(epochs):
        # 训练阶段
        model.train()
        for batch in train_loader:
            # 前向传播、反向传播、参数更新
            ...
        
        # 验证阶段
        model.eval()
        with torch.no_grad():
            ...
        
        # 更新学习率（关键步骤）
        scheduler.step()
        
        # 记录和打印训练信息
        if epoch % 10 == 0:
            print(f'Epoch {epoch} | Train Loss: {train_loss:.4f} | '
                  f'Val Loss: {val_loss:.4f} | LR: {current_lr:.6f}')

实验结果

通过引入余弦退火学习率调度，模型表现有了显著提升：

初始得分：0.80360
优化后最佳得分：0.80734（提升约 0.47%）
训练稳定性：明显改善，避免了学习率过早衰减的问题

技术要点总结

学习率调度的重要性：合适的学习率调度策略可以显著影响模型收敛和最终性能。
余弦退火的优势：
- 平滑的学习率变化减少训练震荡
- 周期性重启帮助跳出局部最优
- 无需手动设置 patience 参数
实践建议：
- 根据数据集大小调整 T_max 参数
- 监控学习率变化确保合理范围
- 结合早停法防止过拟合

进一步优化方向

虽然余弦退火带来了明显改进，但仍有进一步优化的空间：

带热身的余弦退火：使用 CosineAnnealingWarmRestarts 实现更复杂的调度策略
模型架构优化：尝试更深的网络或注意力机制
特征工程：深入挖掘数据特征的相关性

结语

通过这个项目，我深刻体会到学习率调度在深度学习中的重要性。余弦退火作为一种简单而有效的技术，值得在各类分类任务中尝试和应用。机器学习不仅是模型架构的竞赛，更是对训练细节的精心打磨。

完整代码和详细实现请参考我的 Kaggle 笔记本：https://www.kaggle.com/code/kalevyang/notebooke4132da306

基于Vue的棋局数据分析网页

Tue, 28 Oct 2025 08:25:41 GMT

围棋分析系统

从 25 年 1 月初开始学围棋，基本上在野狐围棋上对局。但是苦于野狐围棋并没有个人的黑棋白棋胜率及更多的分析数据，于是想自己实现一个基于 Vue 的棋局数据分析网页

项目概述

这是一个基于 Vue 3 构建的围棋对局分析系统，用于记录、管理和分析围棋对局。系统支持 SGF 文件导入、对局数据存储、胜率统计分析以及棋局详情查看等功能

技术栈

前端框架: Vue 3 + Vite
状态管理: Pinia
路由管理: Vue Router
数据可视化: Chart.js
本地存储: IndexedDB (通过 idb 库)
SGF 解析: @sabaki/sgf
语言: TypeScript
构建工具: Vite

项目结构

├── src/
│   ├── assets/           # 静态资源
│   ├── components/       # 组件
│   ├── lib/              # 工具函数库
│   ├── router/           # 路由配置
│   ├── stores/           # 状态管理
│   ├── types/            # 类型定义
│   ├── views/            # 页面组件
│   ├── App.vue           # 应用根组件
│   └── main.ts           # 入口文件
├── public/               # 公共资源
├── .vscode/              # VSCode配置
├── tsconfig.json         # TypeScript配置
├── vite.config.ts        # Vite配置
└── package.json          # 项目依赖

核心功能模块

1. 数据存储模块

使用 IndexedDB 存储对局数据
提供完整的增删改查操作
通过 idb 库简化 IndexedDB 操作

2. SGF 解析模块

解析 SGF 格式的对局记录
提取对局元数据（日期、对局者、结果等）
提取手数、让子、贴目等信息

3. 对局管理模块

添加对局（支持 SGF 文件导入）
查看对局列表和详情
删除对局记录
筛选和排序功能

4. 数据统计模块

计算并展示总对局数
统计黑棋和白棋胜率
展示胜率趋势图表

关键文件说明

1. 数据存储

src/lib/db.ts: 数据库初始化和配置

import { openDB } from 'idb';

export const initDB = async () => {
  return openDB('GoDB', 1, {
    upgrade(db) {
      if (!db.objectStoreNames.contains('games')) {
        const store = db.createObjectStore('games', { keyPath: 'id', autoIncrement: true });
        store.createIndex('date', 'date');
        store.createIndex('color', 'color');
        store.createIndex('result', 'result');
      }
    }
  });
};

2. 状态管理

src/stores/games.ts: 棋局数据的状态管理
- 存储棋局列表
- 提供数据计算（胜率、弱点分析等）
- 封装数据库操作

3. SGF 解析

src/lib/sgf.ts: SGF 文件解析工具
- 解析 SGF 字符串
- 提取对局信息和手数

4. 页面组件

GameList.vue: 对局列表页面
GameDetail.vue: 对局详情页面
AddGame.vue: 添加对局页面
Statistics.vue: 数据统计页面

路由配置

import { createRouter, createWebHistory } from 'vue-router'
import HomeView from '../views/HomeView.vue'

const router = createRouter({
  history: createWebHistory(import.meta.env.BASE_URL),
  routes: [
    {
      path: '/',
      name: 'home',
      component: HomeView,
    },
    {
      path: '/about',
      name: 'about',
      component: () => import('../views/AboutView.vue'),
    },
    {
      path: '/game-list',
      name: 'game-list',
      component: () => import('../views/GameList.vue'),
    },
    {
      path: '/add-game',
      name: 'add-game',
      component: () => import('../views/AddGame.vue'),
    },
    {
      path: '/statistics',
      name: 'statistics',
      component: () => import('../views/Statistics.vue'),
    },
    {
      path: '/game/:id',
      name: 'game-detail',
      component: () => import('../views/GameDetail.vue'),
    },
  ],
})

export default router

核心数据类型

Game 接口

export interface Game {
  id?: number;
  date: string;
  color: 'black' | 'white';
  opponent: string;
  result: 'win' | 'loss' | 'draw';
  sgf: string;
  createdAt: string;
  analysis?: {
    winRate: number[];
    mistakes: { move: number; position: string; severity: number }[];
  };
}

使用说明

安装依赖

npm install

开发模式启动

npm run dev

构建生产版本

npm run build

预览生产版本

npm run preview

功能说明

添加对局

点击”添加对局”导航
选择 SGF 格式的对局文件
系统自动解析对局信息
确认信息无误后保存对局

查看对局列表

点击”对局列表”导航
可根据结果和颜色进行筛选
列表显示对局的关键信息，包括日期、颜色、对手、手数、让子和结果
点击”查看”按钮进入对局详情
点击”删除”按钮删除对局

查看统计数据

点击”统计”导航
查看总对局数、黑棋胜率和白棋胜率
查看胜率趋势图表

项目特点

本地存储: 所有数据存储在浏览器的 IndexedDB 中，无需后端服务
SGF 支持: 支持标准 SGF 格式的围棋对局文件导入和解析
数据可视化: 使用 Chart.js 提供胜率趋势图表
响应式设计: 适配不同屏幕尺寸
类型安全: 使用 TypeScript 确保代码质量和开发体验

扩展方向

增加 AI 分析功能
添加对局复盘功能
支持多用户数据同步
添加更多统计图表和数据洞察
实现对局评论和笔记功能