Anpier

远程服务器用 aliyunpan 备份 checkpoints

Mon, 08 Jun 2026 00:00:00 GMT

远程服务器的数据盘太小，又不想直接删训练工程和 checkpoints ，所以把这些文件打包传到阿里云盘里备份一下。

用的是 tickstep/aliyunpan，流程很简单：登录阿里云盘，建备份目录，压缩，上传。

准备 aliyunpan

cd ~
wget https://github.com/tickstep/aliyunpan/releases/download/v0.3.9/aliyunpan-v0.3.9-linux-amd64.zip
unzip aliyunpan-v0.3.9-linux-amd64.zip
cd aliyunpan-v0.3.9-linux-amd64
chmod +x aliyunpan

./aliyunpan

aliyunpan > login

终端会给一个登录链接，复制到浏览器里打开。它会先授权一次，再扫码一次，弄完之后回到终端按 Enter。

授权链接就不放原文了，每次生成都不一样，有效时间比较短。

建备份目录

登录成功后，在阿里云盘里建一个按项目和日期分开的目录：

aliyunpan:/ 你的账号名(备份盘)$ mkdir /备份
创建文件夹成功: /备份

aliyunpan:/ 你的账号名(备份盘)$ mkdir /备份/2026-6-8
创建文件夹成功: /备份/2026-6-8

这样之后找文件会方便一点。

打包 checkpoints

服务器上先装一下 zstd：

apt update
apt install -y zstd

这次要备份的目录：

CKPT_DIR=自己填
OUT=自己填

tar --zstd -cvf "$OUT" \
  -C "$(dirname "$CKPT_DIR")" \
  "$(basename "$CKPT_DIR")"

上传

回到 aliyunpan 里面上传：

upload 压缩包地址 /备份/2026-6-8 -ui

传完之后进目录看一眼：

cd /备份/2026-6-8
ls

RSRefSeg2 环境搭建与实验复现（RTX A800）

Sat, 14 Feb 2026 00:00:00 GMT

:::note 要复现论文的github：RSRefSeg2 :::

下载并安装 Miniconda

sudo apt update

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

# 非代理服务器用下面这个
wget https://mirrors.tuna.tsinghua.edu.cn/anaconda/miniconda/Miniconda3-latest-Linux-x86_64.sh

bash Miniconda3-latest-Linux-x86_64.sh

Do you wish the installer to initialize Miniconda3? yes

创建干净环境（Python 3.10）

conda create -n rsrefseg2 python=3.11

conda activate rsrefseg2

安装 A800 的 PyTorch

pip install torch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 -f https://mirrors.aliyun.com/pytorch-wheels/cu121/

安装 MMCV2.2.x

pip install -U openmim

mim install mmcv==2.2.0

安装其他依赖项

pip install deepspeed==0.17.2

pip install transformers==4.53.1 datasets==2.16.1

pip install -U ipdb braceexpand mat4py pycocotools shapely ftfy scipy terminaltables wandb prettytable torchmetrics importlib_metadata einops peft

pip install hydra-core iopath

拉取 RSRefSeg 2 工程

cd ~

git clone https://github.com/KyanChen/RSRefSeg2.git

cd RSRefSeg2

下载 RefSegRS 数据集

export HF_ENDPOINT=https://hf-mirror.com

pip install hf_transfer

export HF_HUB_ENABLE_HF_TRANSFER=1

huggingface-cli download JessicaYuan/RefSegRS \
	--repo-type dataset \
	--local-dir /home/ubuntu/RSRefSeg2/datasets/refsegrs

sudo apt install unzip

unzip RefSegRS.zip -d /home/ubuntu/RSRefSeg2/datasets/refsegrs

RSRefSeg2/datasets/refsegrs
├── images/
├── masks/
├── output_phrase_test.txt
├── output_phrase_train.txt
├── output_phrase_val.txt

下载 RRSIS-D 数据集

huggingface-cli download \
  --repo-type dataset VoyageWang/rrsis-d \
  --local-dir /home/ubuntu/RSRefSeg2/datasets/rrsis_d

unzip JPEGImages.zip -d /home/ubuntu/RSRefSeg2/datasets/rrsis_d/images

ann_split 自行下载

unzip ann_split.zip -d /home/ubuntu/RSRefSeg2/datasets/rrsis_d/images

RSRefSeg2/datasets/rrsis_d
├── rrsisd
│   ├── refs(unc).p
│   └── instances.json
├── images
    └── rrsisd
        ├── JPEGImages/
        └── ann_split/

下载官方 checkpoint

自己创建文件夹 /home/ubuntu/RSRefSeg2/checkpoints

Refsegrs

huggingface-cli download KyanChen/RSRefSeg2 \
  --local-dir /home/ubuntu/RSRefSeg2/checkpoints \
  --local-dir-use-symlinks False \
  --include "refsegrs.pth"

RRSIS-D

huggingface-cli download KyanChen/RSRefSeg2 \
  --local-dir /home/ubuntu/RSRefSeg2/checkpoints \
  --local-dir-use-symlinks False \
  --include "rrsisd.pth"

验证实验

Refsegrs

修改 /home/ubuntu/RSRefSeg2/configs_RSRefSeg2/refsegrs_infer.py 中的数据集与保存路径

work_dir = '/home/ubuntu/RSRefSeg2/work_dirs/refsegrs'
data_root = '/home/ubuntu/RSRefSeg2/datasets/refsegrs/images'
cache_dir = '/home/ubuntu/.cache/hf_models'

python tools_mmseg/test.py configs_RSRefSeg2/refsegrs_infer.py checkpoints/refsegrs.pth

02/14 05:06:32 - mmengine - INFO - per class results:
02/14 05:06:32 - mmengine - INFO - 
+------------+-------+-------+---------+---------+---------+---------+---------+
|   class    |  cIoU |  gIoU | seg_0.5 | seg_0.6 | seg_0.7 | seg_0.8 | seg_0.9 |
+------------+-------+-------+---------+---------+---------+---------+---------+
| background | 98.80 | 98.67 |  100.0  |  99.94  |  99.89  |  99.61  |  98.29  |
|    mask    | 81.21 | 77.36 |  88.11  |  82.94  |  73.97  |  60.81  |  34.40  |
+------------+-------+-------+---------+---------+---------+---------+---------+

RRSIS-D

修改 /home/ubuntu/RSRefSeg2/configs_RSRefSeg2/rrsisd_infer.py 中的数据集与保存路径

work_dir = '/home/ubuntu/RSRefSeg2/work_dirs/rrsis_d'
data_root = '/home/ubuntu/RSRefSeg2/datasets/rrsis_d/images/JPEGImages'
cache_dir = '/home/ubuntu/.cache/hf_models'

python tools_mmseg/test.py configs_RSRefSeg2/rrsisd_infer.py checkpoints/rrsisd.pth

02/14 05:27:16 - mmengine - INFO - per class results:
02/14 05:27:16 - mmengine - INFO - 
+------------+-------+-------+---------+---------+---------+---------+---------+
|   class    |  cIoU |  gIoU | seg_0.5 | seg_0.6 | seg_0.7 | seg_0.8 | seg_0.9 |
+------------+-------+-------+---------+---------+---------+---------+---------+
| background | 98.90 | 98.85 |  100.0  |  99.94  |  99.80  |  99.37  |  97.80  |
|    mask    | 79.66 | 69.06 |  80.03  |  75.64  |  65.18  |  50.59  |  31.08  |
+------------+-------+-------+---------+---------+---------+---------+---------+
``

SAMWISE 环境搭建与实验复现（RTX 5090）

Tue, 10 Feb 2026 00:00:00 GMT

:::note 要复现论文的github：SAMWISE :::

下载并安装 Miniconda

sudo apt update

cd ~

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

bash Miniconda3-latest-Linux-x86_64.sh

Do you wish the installer to initialize Miniconda3? yes

创建干净环境（Python 3.10）

conda create -n samwise python=3.10

conda activate samwise

安装 RTX5090 必须的 PyTorch（Nightly cu128）

pip install --pre torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/nightly/cu128

验证 GPU 是否正确支持

python - <<'PY'
import torch
print("torch:", torch.__version__)
print("cuda runtime:", torch.version.cuda)
print("gpu available:", torch.cuda.is_available())
print("gpu name:", torch.cuda.get_device_name(0))
PY

拉取 SAMWISE 工程

cd ~

git clone https://github.com/ClaudiaCuttano/SAMWISE.git

cd SAMWISE

安装依赖

pip install -U pip

先删除 requirements.txt 中的 pyav ，之后单独装

pip install -r requirements.txt

sudo apt install -y ffmpeg libavdevice-dev libavfilter-dev libavformat-dev libavcodec-dev libswscale-dev libswresample-dev

pip install av==12.0.0

快速 sanity check

python -c "from models.samwise import build_samwise; print('SAMWISE import OK')"

下载Ref-DAVIS17数据集

Downlaod the DAVIS2017 dataset from the website. Note that you only need to download the two zip files DAVIS-2017-Unsupervised-trainval-480p.zip and DAVIS-2017_semantics-480p.zip. Download the text annotations from the website. Then, put the zip files in the directory as follows.

SAMWISE
├── data
│   ├── ref-davis
│   │   ├── DAVIS-2017_semantics-480p.zip
│   │   ├── DAVIS-2017-Unsupervised-trainval-480p.zip
│   │   ├── davis_text_annotations.zip

wget https://data.vision.ee.ethz.ch/csergi/share/davis/DAVIS-2017-Unsupervised-trainval-480p.zip

wget https://data.vision.ee.ethz.ch/csergi/share/davis/DAVIS-2017_semantics-480p.zip

wget https://www.mpi-inf.mpg.de/fileadmin/inf/d2/khoreva/davis_text_annotations.zip

Unzip these zip files.

unzip -o davis_text_annotations.zip
unzip -o DAVIS-2017_semantics-480p.zip
unzip -o DAVIS-2017-Unsupervised-trainval-480p.zip

Preprocess the dataset to Ref-Youtube-VOS format. (Make sure you are in the main directory)

python tools/data/convert_davis_to_ytvos.py

Finally, unzip the file DAVIS-2017-Unsupervised-trainval-480p.zip again (since we use mv in preprocess for efficiency).

unzip -o DAVIS-2017-Unsupervised-trainval-480p.zip

下载 Ref-DAVIS17 Model

SAMWISE
├── pretrain
│   ├── final_model_mevis.pth
│   ├── final_model_ytvos.pth

内网无法访问 google drive，自行下载到电脑上后，上传至服务器

Dataset	Total Parameters	Trainable Params	J&F	Model	Zip
MeViS	210 M	4.9 M	49.5	Weights	Zip
MeViS - valid_u	210 M	4.9 M	57.1	Weights	-
Ref-Youtube-VOS	210 M	4.9 M	69.2	Weights	Zip
Ref-Davis	210 M	4.9 M	70.6	Weights	-

验证 Ref-DAVIS17 实验数据

由于我用的是5090，所以 cuda 和 torch 版本都不太一样

先修改文件 /SAMWISE/inference_davis.py

我的服务器连接不上 huggingface.co ，所以重定向到国内镜像网站 hf-mirror.com

export HF_ENDPOINT=https://hf-mirror.com
export HF_HUB_ENABLE_HF_TRANSFER=0

开始验证：

python3 inference_davis.py --resume=/root/SAMWISE/pretrain/final_model_ytvos.pth --name_exp Ref-DAVIS17-evaluate  --HSA --use_cme_head

aerial-d 环境搭建与实验复现（RTX 5090）

Tue, 10 Feb 2026 00:00:00 GMT

:::note 要复现论文的github：aerial-d :::

下载并安装 Miniconda

sudo apt update

cd ~

wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

bash Miniconda3-latest-Linux-x86_64.sh

Do you wish the installer to initialize Miniconda3? yes

创建干净环境（Python 3.12）

conda create -n aerial python=3.12

conda activate aerial

安装 RTX5090 必须的 PyTorch（Nightly cu128）

pip install --pre torch torchvision torchaudio \
  --index-url https://download.pytorch.org/whl/nightly/cu128

验证 GPU 是否正确支持

python - <<'PY'
import torch
print("torch:", torch.__version__)
print("cuda runtime:", torch.version.cuda)
print("gpu available:", torch.cuda.is_available())
print("gpu name:", torch.cuda.get_device_name(0))
PY

拉取 SAMWISE 工程

cd ~

git clone https://github.com/luispl77/aerial-d.git

cd aerial-d

安装依赖

pip install -U pip

这两句添加注释
# torch==2.7.1
# torchvision==0.22.1

pip install -i https://pypi.org/simple -r requirements.txt

快速 check

python -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0)); print(torch.cuda.get_device_capability(0))"

下载数据集

cd ~/aerial-d

huggingface-cli download luisml77/aerial-d --repo-type dataset --local-dir datagen/dataset

cd ~/aerial-d/datagen/dataset

sudo apt install unzip

unzip aeriald.zip

下载 checkpoint

cd ~/aerial-d/rsrefseg

huggingface-cli download luisml77/rsrefseg \
  --repo-type model \
  --local-dir models

验证实验数据

cd ~/aerial-d

python test.py \
  --model_name rsrefseg_combined \
  --dataset_type aeriald \
  --sam_model facebook/sam-vit-large

Cloudflare Turnstile 为静态博客添加「无感」人机验证

Mon, 09 Feb 2026 00:00:00 GMT

Cloudflare 就是神，不接受反驳

创建 Turnstile 组件

进入 Cloudflare Turnstile 官网，创建组件

:::note 配置建议：

模式：Managed
域名：你的站点域名
预先许可（Cookie）：关闭（我们自己控制） :::

创建完成之后可以看到页面跳转，得到两个值

Site Key（前端用）
Secret Key（服务端用）

在 Pages 中配置 Secret Key

:::note

Name: TURNSTILE_SECRET（一个字母都不能变）
Value: xxxxxxxx（Secret Key） :::

创建 gate 页面（前端）

新建文件：

src/pages/gate.astro

这是一个 自动检测 token → 自动跳转 的代码（YOUR_SITE_KEY自行修改）：

---
const siteKey = "YOUR_SITE_KEY";
const next = Astro.url.searchParams.get("next") ?? "/";
---

<!doctype html>
<html lang="zh-CN">
  <head>
    <meta charset="utf-8" />
    <meta name="viewport" content="width=device-width,initial-scale=1" />
    <title>Human verification</title>
    <script src="https://challenges.cloudflare.com/turnstile/v0/api.js" async defer></script>
  </head>

  <body class="gate">
    <main class="card">
      <h1>正在验证</h1>
      <p class="desc">正常用户将自动通过，请稍候…</p>
      <div class="cf-turnstile" data-sitekey={siteKey}></div>
    </main>

    <script define:vars={{ next }}>
      const timer = setInterval(async () => {
        const tokenEl = document.querySelector(
          'input[name="cf-turnstile-response"]'
        );
        const token = tokenEl?.value;
        if (!token) return;

        clearInterval(timer);

        const res = await fetch("/api/turnstile-verify", {
          method: "POST",
          headers: { "content-type": "application/json" },
          body: JSON.stringify({ token, next }),
        });

        if (res.ok) {
          const data = await res.json();
          location.replace(data.redirect || "/");
        }
      }, 400);
    </script>
  </body>
</html>

服务端校验 Turnstile（Pages Functions）

新建文件（ functions 文件夹在根目录下自行创建）：

functions/api/turnstile-verify.ts

// @ts-nocheck

export const onRequestPost = async (ctx) => {
  const { token, next } = await ctx.request.json().catch(() => ({}));

  if (!token) {
    return new Response("missing token", { status: 400 });
  }

  const form = new FormData();
  form.append("secret", ctx.env.TURNSTILE_SECRET);
  form.append("response", token);

  const ip = ctx.request.headers.get("CF-Connecting-IP");
  if (ip) form.append("remoteip", ip);

  const verify = await fetch(
    "https://challenges.cloudflare.com/turnstile/v0/siteverify",
    {
      method: "POST",
      body: form,
    }
  );

  const result = await verify.json();
  if (!result.success) {
    return new Response("verification failed", { status: 403 });
  }

  const redirect =
    typeof next === "string" && next.startsWith("/") ? next : "/";

  const cookie =
    "cf_human=1; Path=/; Max-Age=43200; HttpOnly; Secure; SameSite=Lax";

  return new Response(JSON.stringify({ redirect }), {
    headers: {
      "content-type": "application/json",
      "set-cookie": cookie,
    },
  });
};

全站拦截（Middleware）

新建文件：

functions/_middleware.ts

// @ts-nocheck

export const onRequest = async (ctx) => {
  const url = new URL(ctx.request.url);
  const path = url.pathname;

  if (
    path.startsWith("/gate") ||
    path.startsWith("/api/turnstile-verify") ||
    path.startsWith("/_astro/") ||
    path.startsWith("/assets/") ||
    path.startsWith("/favicon")
  ) {
    return ctx.next();
  }

  const cookie = ctx.request.headers.get("Cookie") || "";
  const passed = /(?:^|;\s*)cf_human=1(?:;|$)/.test(cookie);

  if (!passed) {
    const next = encodeURIComponent(path + url.search);
    return Response.redirect(`${url.origin}/gate?next=${next}`, 302);
  }

  return ctx.next();
};

部署与测试

将修改后的代码 push 到 github

测试流程

无痕窗口访问首页 → 自动跳 /gate
正常浏览器 → 页面一闪直接回首页
VPN / 异常环境 → 出现 Turnstile 勾选
验证成功后：
- Cookie：cf_human=1
- 12 小时内全站免验证

威联通 NAS + ROG 八爪鱼 + Nextcloud：家庭私有网盘

Sat, 07 Feb 2026 00:00:00 GMT

前言

家里的威联通 NAS 放了很久，说实话一直有点吃灰。

官方应用功能不少，但：

界面复杂
使用路径不直观
更像“系统”，而不是“网盘”

最近正好家里有 公网 IPv4，路由器是 ROG 八爪鱼 ，所以想实现：

像用网盘一样用 NAS，但数据完全在自己家里。

最终方案是：
WireGuard + Nextcloud

我的网络与硬件环境

NAS：威联通 QNAP 464C
路由器：ASUS ROG 八爪鱼
网络：
- 公网 IPv4
- WireGuard 作为唯一远程入口
系统部署方式：Container Station（Docker）

:::note 不暴露公网端口，只通过 VPN 访问私有云服务。 :::

Nextcloud 应用拉取

镜像源使用了国内镜像站，解决拉取超时问题。

以下是我使用的，仅供参考：

version: "3.8"

services:
  nextcloud-db:
    image: docker.1ms.run/library/mariadb:10.11
    container_name: nextcloud-db
    environment:
      MYSQL_ROOT_PASSWORD: "自行设置密码"
      MYSQL_DATABASE: "nextcloud"
      MYSQL_USER: "nextcloud"
      MYSQL_PASSWORD: "自行设置密码"
      TZ: "Asia/Shanghai"
    volumes:
      - /share/Container/nextcloud/db:/var/lib/mysql
    restart: unless-stopped
    networks: [nextcloud-net]

  nextcloud:
    image: docker.1ms.run/linuxserver/nextcloud:latest
    container_name: nextcloud
    ports:
      - "家里NAS的本地IP地址:8383:80"
    volumes:
      - /share/Container/nextcloud/config:/config
      - /share/Container/nextcloud/data:/data
    environment:
      PUID: "1000"
      PGID: "1000"
      TZ: "Asia/Shanghai"
    restart: unless-stopped
    networks: [nextcloud-net]
    depends_on:
      - nextcloud-db
      - onlyoffice

  onlyoffice:
    image: docker.1ms.run/onlyoffice/documentserver:latest
    container_name: onlyoffice
    environment:
      TZ: "Asia/Shanghai"
      JWT_ENABLED: "true"
      JWT_SECRET: "自行设置密码"
      ALLOW_PRIVATE_IP_ADDRESS: "true"
      DB_TYPE: "postgres"
      DB_HOST: "onlyoffice-postgresql"
      DB_PORT: "5432"
      DB_NAME: "onlyoffice"
      DB_USER: "onlyoffice"
      DB_PWD: "自行设置密码"
      AMQP_URI: "amqp://onlyoffice:自行设置密码@onlyoffice-rabbitmq"
    ports:
      - "家里NAS的本地IP地址:8888:80"
    volumes:
      - /share/Container/onlyoffice/logs:/var/log/onlyoffice
      - /share/Container/onlyoffice/data:/var/www/onlyoffice/Data
      - /share/Container/onlyoffice/lib:/var/lib/onlyoffice
      - /share/Container/onlyoffice/db-cache:/var/lib/onlyoffice/documentserver/App_Data/cache/files
      - /share/Container/fonts:/usr/share/fonts/truetype/custom:ro
    restart: unless-stopped
    networks: [nextcloud-net]
    depends_on:
      - onlyoffice-postgresql
      - onlyoffice-rabbitmq

  onlyoffice-postgresql:
    image: docker.1ms.run/library/postgres:12
    container_name: onlyoffice-postgresql
    environment:
      POSTGRES_DB: "onlyoffice"
      POSTGRES_USER: "onlyoffice"
      POSTGRES_PASSWORD: "自行设置密码"
      TZ: "Asia/Shanghai"
    volumes:
      - /share/Container/onlyoffice/pgsql:/var/lib/postgresql/data
    restart: unless-stopped
    networks: [nextcloud-net]

  onlyoffice-rabbitmq:
    image: docker.1ms.run/library/rabbitmq:3
    container_name: onlyoffice-rabbitmq
    environment:
      TZ: "Asia/Shanghai"
      RABBITMQ_DEFAULT_USER: "onlyoffice"
      RABBITMQ_DEFAULT_PASS: "自行设置密码"
    volumes:
      - /share/Container/onlyoffice/rabbitmq:/var/lib/rabbitmq
    restart: unless-stopped
    networks: [nextcloud-net]

networks:
  nextcloud-net:
    driver: bridge

初始化 Nextcloud

第一次访问：

http://NAS内网IP:8383

初始化页面需要注意 数据库主机 这一项：

数据库类型：MySQL / MariaDB
数据库用户：nextcloud
数据库密码：******
数据库名：nextcloud
数据库主机：nextcloud-db:3306

:::note 不要填 localhost
因为 Nextcloud 和数据库在不同容器中。 :::

等待5min后（有概率504，不要管），重新进入该网址，可以看到初始化成功：

路由器配置 DDNS

进入路由器配置界面，我这台路由器的默认本地 IP 是 192.168.50.1：

我这里使用的是 NOIP 的免费服务，每一个账号享有一个，太感谢了！！

自行注册账号并添加：

在 NOIP 添加好之后，在路由器界面填写自己注册的信息，点击 应用本页面设置 ，等待几分钟后，看到注册成功，即成功添加

添加 WireGuard VPN 服务

进入路由器配置界面

创建新的 VPN 客户端，在手机上或者电脑上下载软件 WireGuard ，扫描二维码或者导入配置添加设备

之后哪怕在外面，没有连接到家里的局域网，开启 VPN 也可以用本地 IP 连接到 路由器 和NAS

总结

折腾这一圈，其实NAS 不是不好用，只是以前用法不对。

把复杂的东西都藏在后面，只留下 Nextcloud 这个“入口”，
再用 WireGuard 把访问方式收紧，整个体验一下子就顺了。

现在用起来就是：

在外面先连一下 WireGuard
打开 Nextcloud
跟用普通网盘没什么区别

还不得不感叹一句，华硕的八爪鱼真NB，不愧是钞能力

配置 Vscode + Git + Github

Sun, 11 Jan 2026 00:00:00 GMT

Github 注册

略

下载 Vscode

下载网站：Click!

下载完成后，在 Vscode 中登录自己的 Github账号

下载 & 安装 Git

下载网站：Click!

下载相应版本的 Git ，可以得到:

点击安装：

:::note 没有展示的图片都是默认 :::

配置 Git

打开 Git 终端

用自己 github 的 用户名 和邮箱

git config --global user.name "John Doe" 
git config --global user.email johndoe@example.com

我用的是 V2ray 作为梯子，他的代理端口默认显示在最下方：

如上图可见，我这边的代理端口是10809，接着在 Git 终端中输入：

git config --global http.proxy http://127.0.0.1:10809 
git config --global https.proxy http://127.0.0.1:10809

即可设置代理，提高连接速度

Push 至 Github

如果不经过配置，会出现如下报错：

经检查发现，当开启了“保持邮箱私有（Keep my email addresses private）”选项时，如果本地 Git 使用的是真实邮箱地址进行提交，GitHub 为了保护你的隐私会拦截这次推送

故输入如下代码：

git config --global user.email "你的ID+用户名@users.noreply.github.com"
git commit --amend --reset-author --no-edit

邮箱可在 Github 主页找到：

即可成功解决

ESP32 + 自己编写的组件陈列

Mon, 15 Dec 2025 00:00:00 GMT

板载 RGB

board_rgb

点击下载 : Click!

下载官方 RGB 组件

可以在工程中看到已经导入的组件, 如下图

添加组件

见 ESP32S3 + 组件添加教程

在 main.c 中使用

可看到板载 RGB 以红光闪烁

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_err.h"
#include "board_rgb.h"

static const char *TAG = "main";

static void hsv_to_rgb(float h, float s, float v,
                       uint8_t *r, uint8_t *g, uint8_t *b)
{
    float c = v * s;
    float x = c * (1 - fabsf(fmodf(h / 60.0f, 2) - 1));
    float m = v - c;

    float rf = 0, gf = 0, bf = 0;
    
    if (h < 60) {
        rf = c; gf = x; bf = 0;
    } else if (h < 120) {
        rf = x; gf = c; bf = 0;
    } else if (h < 180) {
        rf = 0; gf = c; bf = x;
    } else if (h < 240) {
        rf = 0; gf = x; bf = c;
    } else if (h < 300) {
        rf = x; gf = 0; bf = c;
    } else {
        rf = c; gf = 0; bf = x;
    }
    
    *r = (uint8_t)((rf + m) * 255);
    *g = (uint8_t)((gf + m) * 255);
    *b = (uint8_t)((bf + m) * 255);

}

void app_main(void)
{
    board_rgb_t rgb = {0};

    ESP_ERROR_CHECK(board_rgb_init(&rgb, 48)); // 我的 RGB LED 连接到 GPIO 48
    
    ESP_LOGI(TAG, "Start rainbow RGB effect");
    
    float hue = 0.0f;
    uint8_t r, g, b;
    
    while (1) {
        hsv_to_rgb(hue, 1.0f, 0.3f, &r, &g, &b); // 0.3 比较柔和，不刺眼
        ESP_ERROR_CHECK(board_rgb_set(&rgb, r, g, b));
    
        hue += 2.0f;          // 调整这个值控制“转得快不快”
        if (hue >= 360.0f) {
            hue = 0.0f;
        }
    
        vTaskDelay(pdMS_TO_TICKS(20)); // 越小越顺
    }

}

GPIO 初始化重写

gpio_setup

点击下载 : Click!

添加组件

见 ESP32S3 + 组件添加教程

在 main.c 中使用

#include <stdio.h>
#include <string.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_err.h"
#include "gpio_setup.h"

void app_main(void)
{
    static const gpio_config_item_t gpio_init_table[] = {
        {
            .gpio_num = GPIO_NUM_48,
            .mode = GPIO_MODE_OUTPUT,
            .pull_up_en = false,
            .pull_down_en = false,
            .level = 0,
            .intr_type = GPIO_INTR_DISABLE,
        },
        {
            .gpio_num = GPIO_NUM_0,
            .mode = GPIO_MODE_INPUT,
            .pull_up_en = true,
            .pull_down_en = false,
            .level = 0,
            .intr_type = GPIO_INTR_DISABLE,
        },
    };

    gpio_setup_init(
        gpio_init_table,
        sizeof(gpio_init_table) / sizeof(gpio_init_table[0])
    );
}

u8g2库点亮 OLED

修改 `main\idf_component.yml`

:::note 不能用 tab 来缩进, 不然会报错 :::

dependencies:
  ## Required IDF version
  idf:
    version: '>=4.1.0'
+ u8g2:
+   git: https://github.com/olikraus/u8g2.git
+ u8g2-hal-esp-idf:
+   git: https://github.com/mkfrey/u8g2-hal-esp-idf.git

编译结束后可在 managed_components 中看到下载好的组件

在 main.c 中使用

#include <stdio.h>
#include <string.h>
#include <math.h>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_err.h"
#include "u8g2.h"
#include "u8g2_esp32_hal.h"

#define PIN_SDA   GPIO_NUM_4 
#define PIN_SCL   GPIO_NUM_5 
#define OLED_I2C_ADDRESS 0x3C

u8g2_t u8g2;

void init_display(void)
{
    u8g2_esp32_hal_t u8g2_esp32_hal = U8G2_ESP32_HAL_DEFAULT;
    u8g2_esp32_hal.bus.i2c.sda = PIN_SDA;
    u8g2_esp32_hal.bus.i2c.scl = PIN_SCL;
    u8g2_esp32_hal_init(u8g2_esp32_hal);
    
    u8g2_Setup_ssd1306_i2c_128x64_noname_f(
        &u8g2, U8G2_R0,
        u8g2_esp32_i2c_byte_cb,
        u8g2_esp32_gpio_and_delay_cb); // init u8g2 structure

    u8x8_SetI2CAddress(&u8g2.u8x8, OLED_I2C_ADDRESS * 2);
    
    u8g2_InitDisplay(&u8g2);
    u8g2_SetPowerSave(&u8g2, 0);
    u8g2_ClearBuffer(&u8g2);
    
    u8g2_SetFont(&u8g2, u8g2_font_ncenB10_tr);
}

// 绘制函数示例
void draw_content(void) {
    u8g2_FirstPage(&u8g2);
    do {
        u8g2_DrawStr(&u8g2, 0, 15, "S3 OLED Demo!");
        u8g2_DrawStr(&u8g2, 0, 30, "Adrian!");
    } while (u8g2_NextPage(&u8g2));
}

void app_main(void)
{
    init_display();
    
    while(1) {
       draw_content();
       vTaskDelay(pdMS_TO_TICKS(5));
    }
}

OLED 0.96寸函数封装

oled_iic_0.96

点击下载 : Click!

添加组件

见 ESP32S3 + 组件添加教程

在 main.c 中使用

#include "u8g2.h"
#include "u8g2_esp32_hal.h"

#define PIN_SDA   GPIO_NUM_4 
#define PIN_SCL   GPIO_NUM_5 
#define OLED_I2C_ADDRESS 0x3C

u8g2_t u8g2;

void init_display(void)
{
	//设置一下使用的引脚
    u8g2_esp32_hal_t u8g2_esp32_hal = U8G2_ESP32_HAL_DEFAULT;
    u8g2_esp32_hal.bus.i2c.sda = PIN_SDA;
    u8g2_esp32_hal.bus.i2c.scl = PIN_SCL;
    u8g2_esp32_hal_init(u8g2_esp32_hal);
    
    // 针对不同的屏幕使用不同的初始化函数
    u8g2_Setup_ssd1306_i2c_128x64_noname_f(
        &u8g2, U8G2_R0,
        u8g2_esp32_i2c_byte_cb,
        u8g2_esp32_gpio_and_delay_cb); // init u8g2 structure
        
    // 0x3c -> 0x78 (I2C 地址乘以 2)
    u8x8_SetI2CAddress(&u8g2.u8x8, OLED_I2C_ADDRESS * 2); // **已修正：确保乘以 2**
    
    u8g2_InitDisplay(&u8g2);     // send init sequence to the display
    u8g2_SetPowerSave(&u8g2, 0); // wake up display
    u8g2_ClearBuffer(&u8g2);
    
    // 建议设置一个默认字体
    u8g2_SetFont(&u8g2, u8g2_font_ncenB10_tr);
}

// 绘制函数示例
void draw_content(void) {
    u8g2_FirstPage(&u8g2);
    do {
        u8g2_DrawStr(&u8g2, 0, 15, "S3 OLED Demo!");
        u8g2_DrawStr(&u8g2, 0, 30, "Adrian!");
    } while (u8g2_NextPage(&u8g2));
}

void app_main(void)
{
    init_display();
    
    while(1) {
       draw_content();
       vTaskDelay(pdMS_TO_TICKS(5));
    }
}

#include "oled_iic_0.96.h"

void app_main(void)
{
    oled_iic_096_init(4, 5, 0x3C, NULL);
    //oled_iic_096_demo("Adrian");
    u8g2_t *u8g2 = oled_iic_096_get_u8g2();
    
    while(1)
    {
        u8g2_ClearBuffer(u8g2);
        u8g2_DrawStr(u8g2, 38, 18, "Adrian");
        u8g2_SendBuffer(u8g2);
    }

}

HCSR04 超声波传感器

hscr04

点击下载 : Click!

添加组件

见 ESP32S3 + 组件添加教程

在 main.c 中使用

#include "hcsr04.h"
#include "oled_iic_0.96.h"

void app_main(void)
{
     hcsr04_config_t cfg = {
        .trig_gpio = 18,          
        .echo_gpio = 17,          
        .sound_speed_m_s = 343.0f,
        .timeout_us = 10000,
    };
    ESP_ERROR_CHECK(hcsr04_init(&cfg));

    while(1)
    {
        u8g2_ClearBuffer(u8g2);
        int16_t mm = 0;
        esp_err_t err = hcsr04_read_mm(&mm);

        char line1[32];
        char line2[32];

        if (err == ESP_OK)
        {
            float cm = mm / 10.0f;
            snprintf(line1, sizeof(line1), "mm: %d", (int)mm);
            snprintf(line2, sizeof(line2), "cm: %.1f", cm);
            u8g2_DrawStr(u8g2, 30, 35, line1);
            u8g2_DrawStr(u8g2, 30, 51, line2);
        } 
        else 
        {
            snprintf(line1, sizeof(line1), "Read failed");
            snprintf(line2, sizeof(line2), "%s", esp_err_to_name(err));
            u8g2_DrawStr(u8g2, 30, 35, line1);
            u8g2_DrawStr(u8g2, 30, 51, line2);
        }
    }
}

Astro 和 Fuwari 的部署优化指南

Sun, 14 Dec 2025 00:00:00 GMT

添加友链

添加友链页面文件

在src\content\spec目录下新建文件friends.md

在src\types\config.ts文件约41行位置添加以下内容

export enum LinkPreset {
    Home = 0,
    Archive = 1,
    About = 2,
+   Friends = 3,
}

国际化i18n翻译

在src\i18n\i18nKey.ts文件约35行位置添加以下内容

    author = "author",
    publishedAt = "publishedAt",
    license = "license",
+   friends = 'friends',

按照自己的语言，在 src\i18n\languages 目录中编辑相应语言文件,以 zh_CN.ts 为例，在约 38 行位置添加内容

    [Key.author]: "作者",
    [Key.publishedAt]: "发布于",
    [Key.license]: "许可协议",
+   [Key.friends]: '友链',

在 src\constants\link-presets.ts 文件约 18 行位置添加内容

	[LinkPreset.Archive]: {
        name: i18n(I18nKey.archive),
        url: "/archive/",
    },
+   [LinkPreset.Friends]: {
+       name: i18n(I18nKey.friends),
+       url: '/friends/',
+   },
};

创建和配置页面的Astro文件并创建卡片效果友链

在src\pages目录下复制原本的about.astro文件，重命名为friends.astro

---
import MainGridLayout from '../layouts/MainGridLayout.astro'
import { getCollection } from 'astro:content'
import { i18n } from '../i18n/translation'
import I18nKey from '../i18n/i18nKey'
import Markdown from '@components/misc/Markdown.astro'

const specPosts = await getCollection('spec')
const friendsPost = specPosts.find(post => post.id === 'friends.md')
const { Content } = await friendsPost.render()

const items = [
  {  
    title: 'Astro',  
    imgurl: 'https://avatars.githubusercontent.com/u/44914786?s=48&v=4',  
    desc: 'The web framework for content-driven websites. ⭐️ Star to support our work!',  
    siteurl: 'https://github.com/withastro/astro',  
    tags: [''],  
  },
 
]
---
<MainGridLayout title={i18n(I18nKey.friends)} description={i18n(I18nKey.friends)}>
    <div class="flex w-full rounded-[var(--radius-large)] overflow-hidden relative min-h-32">
        <div class="card-base z-10 px-9 py-6 relative w-full "> 
            <div class="grid grid-cols-1 sm:grid-cols-2 gap-x-6 gap-y-8 my-4">
                {items.map((item) => (   
                    <div class="flex flex-nowrap items-stretch h-28 gap-4 rounded-[var(--radius-large)]">
                        <div class="w-28 h-28 flex-shrink-0 rounded-lg overflow-hidden bg-zinc-200">
                            <img src={item.imgurl} alt="站点头像" class="w-full h-full object-cover">
                        </div>
                        <div class="grow w-full">
                            <div class="font-bold transition text-lg text-neutral-900 mb-1">{item.title}</div>
                            <div class="text-50 text-sm font-medium">{item.desc}</div>
                            <div class:list={["items-center", {"flex": true, "hidden md:flex" : false}]}>
                                <div class="flex flex-row flex-nowrap items-center">
                                    {(item.tags && item.tags.length > 0) && item.tags.map((tag,i) => (  
                                    <div class:list={[{"hidden": i==0}, "mx-1.5 text-[var(--meta-divider)] text-sm" ]}>
                                        /
                                    </div>  
                                    <span class="transition text-50 text-sm font-medium">
                                        {tag}
                                    </span>))}
                                    {!(item.tags && item.tags.length > 0) && <div class="transition text-50 text-sm font-medium">{i18n(I18nKey.noTags)}</div>}
                                </div>
                            </div>
                        </div>
                        <a href={item.siteurl} target="_blank" rel="noopener noreferrer"class="flex btn-regular w-[3.25rem] rounded-lg bg-[var(--enter-btn-bg)] hover:bg-[var(--enter-btn-bg-hover)] active:bg-[var(--enter-btn-bg-active)] active:scale-95">
                            <svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="transition text-[var(--primary)] text-4xl mx-auto iconify iconify--material-symbols" width="1em" height="1em" viewBox="0 0 24 24">
                                <path fill="currentColor" d="M12.6 12L8.7 8.1q-.275-.275-.275-.7t.275-.7t.7-.275t.7.275l4.6 4.6q.15.15.213.325t.062.375t-.062.375t-.213.325l-4.6 4.6q-.275.275-.7.275t-.7-.275t-.275-.7t.275-.7z"></path>
                            </svg>
                        </a>
                    </div>
                ))}
            </div>  
            <Markdown class="mt-2"> 
                <Content />
            </Markdown>
        </div>
    </div>
</MainGridLayout>

在导航栏中添加友链页面

在 src\config.ts 文件约 48 行位置添加内容，注意要在 LinkPreset.About 末尾添加,

export const navBarConfig: NavBarConfig = {
  links: [
    LinkPreset.Home,
    LinkPreset.Archive,
+   LinkPreset.About,
+   LinkPreset.Friends,
    {

新窗口/新标签页打开

安装/更新 `rehype-external-links`

pnpm add rehype-external-links

修改 `astro.config.mjs`

rehypePlugins: [
  rehypeKatex,
  rehypeSlug,
  [
+   rehypeExternalLinks,
+   {
+     target: "_blank",
+     rel: ["noopener", "noreferrer"],
+   },
+ ],
  // 后面的 rehypeComponents / rehypeAutolinkHeadings 保持不动
  ...
]

Github + PicGo 搭建图床教程

Sat, 13 Dec 2025 00:00:00 GMT

创建 Github 仓库

创建 Token

进入账号 Settings

左侧栏最下方 Developer settings

选择创建 classic Token

内容填写如下

:::note 务必记住 Token 的内容,只会出现一次 :::

编辑 Picgo

即搭建完成

ESP32S3 + 组件添加教程

Sat, 13 Dec 2025 00:00:00 GMT

组件修改流程

组件结构

your_project/
├─ CMakeLists.txt          ← 根 CMake，不用改
├─ main/
│  ├─ CMakeLists.txt       ← 根 CMake，需要修改
│  └─ main.c
└─ components/
   └─ COMPONENT_NAME/      ← COMPONENT_NAME 为组件名字
      ├─ CMakeLists.txt
      ├─ COMPONENT_NAME.c
      └─ include/
         └─ COMPONENT_NAME.h

添加组件

下载或者自行编写组件文件, 将其放入 components 文件夹中

:::note components可能需要自行创建 :::

修改工程 CMakeLists.txt

:::note 注意, 是 main\CMakeLists.txt :::

修改如下, 将名为 components 的目录添加到额外的组件搜索路径中

idf_component_register(
    SRCS "main.c"
    INCLUDE_DIRS "."
+   REQUIRES board_rgb 添加自己组件.h的名字
)

腾讯云COS对象存储 + PicGo 搭建图床教程

Mon, 01 Dec 2025 00:00:00 GMT

PicGo 安装

给出官方GitHub网站, 自行下载

::github{repo="Molunerfinn/PicGo"}

创建存储桶

来到腾讯云对象存储控制台，创建存储

访问权限选择 公有读私有写 ，否则图片无法读取，其他的根据自己往下填写就可以。地域建议离你所在的位置越近越好。

创建密钥

腾讯云头像–>访问管理–> API密钥管理，创建密钥，就会生成 APPID、SecretId和SecretKey

:::note 请务必保存好自己的密钥 :::

PicGo设置

配置完即可顺利上传了, 还有很多功能自行探索

STM32解析富斯i6遥控器和FS-iA6B接收机的ibus通信

Sat, 01 Nov 2025 00:00:00 GMT

对码

具体观看该视频：

接线

STM32接线略

程序

下载 remote.c 与 remote.h 文件： Click!

现象

帧模式

STM32 Debug

STM32H743XIH6 + HAL库 + CubeMX配置

Wed, 29 Oct 2025 00:00:00 GMT

CubeMX配置

芯片选择STM32H743XIH6，TFBGA 240封装

RCC配置

HSE高速时钟使用外部晶振，其他采用默认设置。

接下来配置时钟

GPIO配置

我这块板子上默认是PC13作为LED灯控制引脚：

DEBUG配置

:::note 该项一定要配置！！！ :::

我采用SW模式进行下载和调试程序：

生成代码

部分设置如图所示：

最后点击 GENERATE CODE 生成代码

Keil5

Target配置

打开 Target 选项卡：

框中选项必须勾选，否则串口重定向后无法使用printf函数，程序会卡死：

框中选项必须勾选，以便程序可以右键跳转到函数或变量定义处：

框中选择自己使用的仿真器，我用的是ST-Link，点击Settings后如下图所示：

框中选项必须勾选

Configuration配置

打开 Configuration 选项卡：

我习惯于使用 UTF-8 格式，并且加上代码补全提示：

深度学习工程模板

Sun, 26 Oct 2025 00:00:00 GMT

Import

import os
import cv2
import PIL
import torch
import torchvision
import numpy as np
from torch import nn
from torch.utils.data import DataLoader
from torchvision.models import VGG16_Weights
from torch.utils.tensorboard import SummaryWriter

GPU训练

device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print("使用设备：{}".format(device))

准备&加载数据集

# 准备数据集
train_dataset = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10",
    train       = True,
    download    = True,
    transform   = torchvision.transforms.ToTensor()
)
train_dataset_size = len(train_dataset)
  
test_dataset = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10",
    train       = False,
    download    = True,
    transform   = torchvision.transforms.ToTensor()
)
test_dataset_size  = len(test_dataset)

print("----数据集导入成功----")
print("训练集大小：{}".format(train_dataset_size))
print("测试集大小：{}".format(test_dataset_size))


# 加载数据集
train_dataloader = DataLoader(
    dataset     = train_dataset,
    batch_size  = 64,
    shuffle     = True,
    num_workers = 0,
    drop_last   = False
)

test_dataloader = DataLoader(
    dataset     = test_dataset,
    batch_size  = 64,
    shuffle     = True,
    num_workers = 0,
    drop_last   = False
)

创建网络模型

class My_Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1      = nn.Conv2d(
            in_channels     = 3, 
            out_channels    = 32, 
            kernel_size     = 5, 
            padding         = 2
        )
        self.maxpool1   = nn.MaxPool2d(
            kernel_size = 2,
        )
        self.conv2      = nn.Conv2d(
            in_channels     = 32, 
            out_channels    = 32, 
            kernel_size     = 5, 
            padding         = 2
        )
        self.maxpool2   = nn.MaxPool2d(
            kernel_size = 2,
        )
        self.conv3      = nn.Conv2d(
            in_channels     = 32, 
            out_channels    = 64, 
            kernel_size     = 5, 
            padding         = 2
        )
        self.maxpool3   = nn.MaxPool2d(
            kernel_size = 2,
        )
        self.flatten    = nn.Flatten()
        self.linear1    = nn.Linear(
            in_features    = 64 * 4 * 4,    
            out_features   = 64
        )
        self.linear2    = nn.Linear(
            in_features    = 64,
            out_features   = 10
        )
        self.seq        = nn.Sequential(
            self.conv1,
            self.maxpool1,
            self.conv2,
            self.maxpool2,
            self.conv3,
            self.maxpool3,
            self.flatten,
            self.linear1,
            self.linear2
        )
    
    def forward(self, input):
        output = self.seq(input)
        return output
    
my_model = My_Model()
my_model = my_model.to(device)

损失函数

loss_fn = nn.CrossEntropyLoss()
loss_fn = loss_fn.to(device)

优化器

Learnig_rate = 0.002
optim = torch.optim.Adam(
    params      = my_model.parameters(),
    lr          = Learnig_rate
)

设置训练参数&开始训练

total_train_step = 0 # 记录训练的次数
total_test_step  = 0 # 记录测试的次数
epoch = 10          # 训练轮数
writer = SummaryWriter("./logs")  # TensorBoard 日志保存路径

for i in range(epoch):
    print("--------第 {} 轮训练开始--------".format(i + 1))
    
    # 训练步骤
    my_model.train()
    for data in train_dataloader:
        imgs, targets = data
        imgs    = imgs.to(device)
        targets = targets.to(device)
        
        outputs = my_model(imgs)
        loss = loss_fn(outputs, targets)

        optim.zero_grad()   # 清空上一步的残余更新参数值
        loss.backward()     # 反向传播，计算参数更新值
        optim.step()       # 更新参数

        total_train_step += 1
        if total_train_step % 100 == 0:
            print("训练次数：{}，Loss：{}".format(total_train_step, loss.item()))
            writer.add_scalar("train_loss", loss.item(), total_train_step)

    torch.save(my_model.state_dict(), "./My_Model/model_{}.pth".format(i))
    print("模型已保存")

    # 测试步骤
    my_model.eval()
    total_test_loss = 0
    total_accuracy  = 0
    with torch.no_grad():
        for data in test_dataloader:
            imgs, targets = data
            imgs    = imgs.to(device)
            targets = targets.to(device)

            outputs = my_model(imgs)
            loss = loss_fn(outputs, targets)
            total_test_loss += loss.item()
            accuracy = (outputs.argmax(1) == targets).sum()
            total_accuracy += accuracy

    print("整体测试集上的Loss：{}".format(total_test_loss))
    print("整体测试集上的正确率：{}".format(total_accuracy / test_dataset_size))
    writer.add_scalar("test_loss", total_test_loss, total_test_step)
    writer.add_scalar("test_accuracy", total_accuracy / test_dataset_size, total_test_step)
    total_test_step += 1

配置 ESP32 + VScode + ESP-IDF 环境

Thu, 23 Oct 2025 00:00:00 GMT

VScode下载

略

离线安装 ESP-IDF 环境

IDF 下载

IDF离线下载网址：https://dl.espressif.cn/dl/esp-idf/

IDF 安装

:::note 安装时必须关闭VSCode! :::

:::note 在安装期间会弹出是否安装驱动的提示框，选择安装或者同意即可 :::

安装并配置 IDF 插件

随后等待安装完成即可

上图即为安装成功

新建工程并测试

随后右下角会提示【工程已经创建完毕，是否用新窗口打开工程？】，打开即可

烧录后，输出提示如下

终端提示如下

即环境安装成功

配置参数

:::note 这个每一个 ESP32 都不一样, 请根据自己买的型号修改我买的是S3 N16R8 :::

:::note 如需要转移环境使用工程，请删除 build 文件夹后再尝试编译 :::

深度学习常用库

Tue, 21 Oct 2025 00:00:00 GMT

All Import

import os
import cv2
import torch
import torchvision
import numpy as np
from PIL import Image
from torch import nn
from torch.utils.data import Dataset 
from torch.utils.data import DataLoader  
from torch.utils.tensorboard import SummaryWriter
from torch.nn import functional as F

Data

import torch
from torch.utils.data import Dataset 
from torch.utils.data import DataLoader 
import os

Dataset

Dataset??       #查看Dataset类的官方介绍  
help(Dataset)   #查看Dataset类的官方介绍

from torch.utils.data import Dataset

class MyDataSet(Dataset):
    def __init__(self, root_dir, label_dir):
        self.root_dir       = root_dir
        self.label_dir      = label_dir
        self.path           = os.path.join(self.root_dir, self.label_dir)
        self.img_path_list  = os.listdir(self.path)

    def __len__(self):
        return len(self.img_path_list)
        
    def __getitem__(self, idx):
        img_name    = self.img_path_list[idx]
        img_path    = os.path.join(self.path, img_name)
        img         = Image.open(img_path)
        label       = self.label_dir
        
        return img, label

my_dataset = MyDataSet("root_dir", "label_dir")
print(len(my_dataset))
img, label = my_dataset[idx]

Dataloader

from torch.utils.data import DataLoader

# 加载 CIFAR10 测试集，应用 ToTensor 转换
test_dataset = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10", 
    train       = False, 
    download    = True, 
    transform   = torchvision.transforms.ToTensor()
)

# 创建测试集 DataLoader
test_loader = DataLoader(
    dataset     = test_dataset, 
    batch_size  = 64, 
    shuffle     = True, 
    num_workers = 0, 
    drop_last   = False
)

# 测试 DataLoader
writer = SummaryWriter("CIFAR10_DataLoader")

for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs, targets = data
        # print(imgs.shape)      # torch.Size([4, 3, 32, 32])
        # print(targets)         # tensor([6, 9, 2, 4])
        writer.add_images("Epoch:{}".format(epoch), imgs, step)
        step += 1


writer.close()

CV2 & Image

Image

from PIL import Image

# 打开图片
img = Image.open("test.jpg")

# 显示图片
img.show()

# 转换格式
img = img.convert("L")   # 转为灰度图

# 调整大小
img = img.resize((200, 200))

# 保存图片
img.save("out.png")

CV2

pip install opencv-python

import cv2

# 读取图片
img = cv2.imread("test.jpg")

# 显示图片
cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

# 转为灰度
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

# 图像处理
blur = cv2.GaussianBlur(gray, (5, 5), 0)
edges = cv2.Canny(blur, 100, 200)

# 保存结果
cv2.imwrite("edges.jpg", edges)

TensorBoard

pip install tensorboard

Tensorboard??      #查看Tensorboard类的官方介绍  
help(Tensorboard)   #查看Tensorboard类的官方介绍

import numpy as np
from torch.utils.tensorboard import SummaryWriter

writer = SummaryWriter("My_TensorBoard")

writer.add_image()

img_path = "Relative_Image_Path"
img_PIL = Image.open(img_path)
img_array = np.array(img_PIL)
print(type(img_array))
print(img_array.shape)  # (512, 768, 3)
                        # HWC---------------------------------------
                        #                                          |
writer.add_image("Ant Image from PIL", img_array, 0, dataformats='HWC')

writer.add_scalar()

# y = 2x 
for i in range(100):
    writer.add_scalar("y=2x", 2*i, i)

writer.close()

启动

本地启动TensorBoard（ logdir=事件文件所在文件夹名 ）

tensorboard --logdir=My_TensorBoard --port=6007

Transform

from torchvision import transforms

writer = SummaryWriter("My_TensorBoard")

# 跨平台路径 + 确保RGB
img_path = os.path.join("dataset", "hymenoptera_data", "train", "ants", "0013035.jpg")
img_PIL = Image.open(img_path).convert("RGB")

transforms.ToTensor

#img PIL -> tensor
img_tensor = transforms.ToTensor()(img_PIL)

writer.add_image("PIL IMG", img_tensor, 0)

transforms.Resize

#img PIL -> Resize -> tensor
img_resize_PIL = transforms.Resize((256, 256))(img_PIL)
img_resize_tensor = transforms.ToTensor()(img_resize_PIL)

writer.add_image("Resize IMG", img_resize_tensor, 0)

transforms.RandomCrop

# Random Crop（若不确定原图尺寸，考虑换 RandomResizedCrop(256)）
for i in range(5):
    img_random_crop_PIL = transforms.RandomCrop((256, 256))(img_PIL)
    img_random_crop_tensor = transforms.ToTensor()(img_random_crop_PIL)
    writer.add_image("Random Crop IMG", img_random_crop_tensor, i)

transforms.Normalize

# Tensor -> Normalize（训练用）；可视化时要反归一化
img_norm = transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])(img_tensor)
img_norm_vis = img_norm * 0.5 + 0.5        # 仅用于可视化

writer.add_image("Normalize IMG (for view)", img_norm, 0)
writer.add_image("Normalize IMG (for view)", img_norm_vis, 1)

transforms.Compose

# Compose: resize -> tensor -> normalize
transform = transforms.Compose([
    transforms.Resize((256, 256)),
    transforms.ToTensor(),
    transforms.Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5])
])
img_composed = transform(img_PIL)

# 可视化时反归一化
img_composed_vis = img_composed * 0.5 + 0.5

writer.add_image("Tensor IMG (composed, for view)", img_composed, 0)
writer.add_image("Tensor IMG (composed, for view)", img_composed_vis, 1)

Torchvision

Download & Use Dataset

数据集下载官网： CIFAR10

# transform 预处理
dataset_transform = torchvision.transforms.Compose([
    torchvision.transforms.Resize((32, 32)),
    torchvision.transforms.ToTensor()
])

# 官方数据集导入 & 使用
train_set = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10", 
    train       = True, 
    download    = True, 
    transform   = dataset_transform
)


test_set = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10", 
    train       = False,
    download    = True, 
    transform   = dataset_transform
)

img, label = train_set[idx]
print(train_set[idx])
img.show()

print(f"类别名称: {train_set.classes}")
print(f"类别名称与索引映射: {train_set.class_to_idx}")

print(f"图像尺寸: {img.size}, 图像类型: {type(img)}, 标签: {label}", f"标签名称: {train_set.classes[label]}")

print(f"训练集样本数: {len(train_set)}")
print(f"测试集样本数: {len(test_set)}")

NN

官网介绍：NN

# 加载 CIFAR10 测试集，应用 ToTensor 转换
test_dataset = torchvision.datasets.CIFAR10(
    root        = "./dataset/CIFAR10",
    train       = False,
    download    = True,
    transform   = torchvision.transforms.ToTensor()
)

# 创建测试集 DataLoader
test_loader = DataLoader(
    dataset     = test_dataset,
    batch_size  = 64,
    shuffle     = True,
    num_workers = 0,
    drop_last   = False
)

Class

class Model(nn.Module):
    def __init__(self) -> None:
        super().__init__()
        self.conv1 = nn.Conv2d(1, 20, 5)
        self.conv2 = nn.Conv2d(20, 20, 5)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        return F.relu(self.conv2(x))

My_model = Model()
X = torch.tensor([1.0, 2.0, 3.0])
output = My_model(X)

Convolution Layers

from torch import nn
import torch.nn.functional as F

Conv2d ()

官方介绍：Conv2d()

动图解释：Click!

函数式调用

torch.nn.functional.conv2d( input, 
							weight, 
							bias     = None, 
							stride   = 1, 
							padding  = 0, 
							dilation = 1, 
							groups   = 1)

input = torch.tensor([[1, 2, 0, 3, 1],
                      [0, 1, 2, 3, 1],
                      [1, 2, 1, 0, 0],
                      [5, 2, 3, 1, 1],
                      [2, 1, 0, 1, 1]])

kernel = torch.tensor([[1, 2, 1],
                       [0, 1, 0],
                       [2, 1, 0]])

input = torch.reshape(input, (1, 1, 5, 5))  # (N, C, H, W)
kernel = torch.reshape(kernel, (1, 1, 3, 3))  # (out_C, in_C, kH, kW)

print("input shape:", input.shape)    
print("kernel shape:", kernel.shape)

output = F.conv2d(input, kernel, stride=1, padding=0)

print("output shape:", output.shape) # (1, 1, 3, 3)
print(output)

output = F.conv2d(input, kernel, stride=2, padding=0)

print("output shape:", output.shape) # (1, 1, 2, 2)
print(output)

output = F.conv2d(input, kernel, stride=1, padding=1)

print("output shape:", output.shape) # (1, 1, 5, 5)
print(output)

模块化层（推荐）

class My_Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = torch.nn.Conv2d(
            in_channels     = 3,
            out_channels    = 16,
            kernel_size     = 3,
            stride          = 1,
            padding         = 1
        )

    def forward(self, x):
        x = self.conv1(x)
        return x

wrtiter = SummaryWriter("CIFAR10_Conv2d")

step = 0

My_model = My_Model()

for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs, targets = data
        output = My_model(imgs)

        # print("input shape:", imgs.shape)
        # print("output shape:", output.shape)

        wrtiter.add_images("Input:{}".format(epoch), imgs, step)

        output = output[:, :3, :, :]  # 只取前3个通道，方便可视化
        wrtiter.add_images("Onput:{}".format(epoch), output, step)

        step += 1

print("Done.")

MaxPool Layers

官方介绍：MaxPool2d()

class My_Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.maxpool1 = torch.nn.MaxPool2d(
            kernel_size     = 3, 
            ceil_mode       = True,
            stride          = 2,
            padding         = 1
        )

    def forward(self, x):
        x = self.maxpool1(x)
        return x

wtriter = SummaryWriter("CIFAR10_NN_MaxPool2d")

My_model = My_Model()
step = 0
for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs, targets = data
        output = My_model(imgs)

        # print("input shape:", imgs.shape)
        # print("output shape:", output.shape)

        wtriter.add_images("Input:{}".format(epoch), imgs, step)
        wtriter.add_images("Output:{}".format(epoch), output, step)

        step += 1

print("Done.")

Non Linear Layers

class My_Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.ReLU1 = torch.nn.ReLU()
        self.sigmoid1 = torch.nn.Sigmoid()

    def forward(self, x):
        # x = self.ReLU1(x)
        x = self.sigmoid1(x)
        return x

wtriter = SummaryWriter("CIFAR10_NN_Non_Linear_Act")

My_model = My_Model()
step = 0
for epoch in range(2):
    step = 0
    for data in test_loader:
        imgs, targets = data
        output = My_model(imgs)

        # print("input shape:", imgs.shape)
        # print("output shape:", output.shape)

        wtriter.add_images("Input:{}".format(epoch), imgs, step)
        wtriter.add_images("Output:{}".format(epoch), output, step)

        step += 1

print("Done.")

Linear Layers

class My_Model(torch.nn.Module):
    def __init__(self):
        super().__init__()
        self.linear1 = torch.nn.Linear(
            in_features    = 3 * 32 * 32, 
            out_features   = 10
        )

    def forward(self, input):
        output = self.linear1(input) 
        return output

My_model = My_Model()
step = 0
for epoch in range(1):
    step = 0
    for data in test_loader:
        imgs, targets = data
        print("imgs shape before flatten:", imgs.shape)

        #imgs = imgs.view(imgs.size(0), -1)  # 展平操作
        imgs = torch.flatten(imgs, start_dim=1)  # 另一种展平操作
        print("imgs shape after flatten:", imgs.shape)

        output = My_model(imgs)
        print("output shape:", output.shape)

        step += 1

print("Done.")

Sequential

class My_Model(nn.Module):
    def __init__(self):
        super().__init__()
        self.conv1 = nn.Conv2d(
            in_channels     = 3, 
            out_channels    = 32, 
            kernel_size     = 5, 
            padding         = 2
        )

        self.maxpool1 = nn.MaxPool2d(
            kernel_size = 2,
        )

        self.conv2 = nn.Conv2d(
            in_channels     = 32, 
            out_channels    = 32, 
            kernel_size     = 5, 
            padding         = 2
        )

        self.maxpool2 = nn.MaxPool2d(
            kernel_size = 2,
        )

        self.conv3 = nn.Conv2d(
            in_channels     = 32, 
            out_channels    = 64, 
            kernel_size     = 5, 
            padding         = 2
        )

        self.maxpool3 = nn.MaxPool2d(
            kernel_size = 2,
        )

        self.flatten = nn.Flatten()

        self.linear1 = nn.Linear(
            in_features    = 64 * 4 * 4,    
            out_features   = 64
        )

        self.linear2 = nn.Linear(
            in_features    = 64,
            out_features   = 10
        )

        self.seq = nn.Sequential(
            self.conv1,
            self.maxpool1,
            self.conv2,
            self.maxpool2,
            self.conv3,
            self.maxpool3,
            self.flatten,
            self.linear1,
            self.linear2
        )
    
    def forward(self, input):
        output = self.seq(input)
        return output

my_model = My_Model()
print(my_model)

input = torch.randn(64, 3, 32, 32)
print("input shape:", input.shape)
print("input:", input)

output = my_model(input)
print("output shape:", output.shape)
print("output:", output)

Loss Function

官方文档：Click !

 # 定义损失函数
criterion = nn.CrossEntropyLoss()
        
# 计算损失
loss = criterion(outputs, targets)

#具体其他的损失函数及其参数可翻阅文档查看

Backward & Optimizer

官方文档：Backward

官方文档：Optim

optim = torch.optim.SGD(
    params      = my_model.parameters(),
    lr          = 0.01,
)

for epoch in range(20):
    running_loss = 0.0

    for data in train_loader:
        imgs, targets = data
        outputs = my_model(imgs)
        
        # 定义损失函数
        criterion = nn.CrossEntropyLoss()
        
        # 计算损失
        loss = criterion(outputs, targets)
      
        optim.zero_grad()  # 清零梯度
        loss.backward()
        optim.step()       # 更新参数

        running_loss += loss.item()

    print(f"epoch {epoch} finished!")    
    print("loss:", running_loss)

模型保存与使用

以VGG16为例，这个模型数据集150G，就别下载了···

载入模型

from torchvision.models import VGG16_Weights

# 模型文件保存路径
os.environ['TORCH_HOME'] = r'E:\Deep_Learning\project\dataset\ImageNet'

# 不加载权重
VGG16_MODEL_False = torchvision.models.vgg16(weights = None)

# 加载 ImageNet 预训练权重
VGG16_MODEL_True = torchvision.models.vgg16(weights=VGG16_Weights.IMAGENET1K_V1)

修改模型

例：CIFAR-10（10类）

只需替换最后的全连接层：

import torch.nn as nn
import torchvision

# 不加载预训练权重（如果你想从头训练）
model1 = torchvision.models.vgg16(weights=None)

# 修改分类器最后一层
model1.classifier[6] = nn.Linear(in_features=4096, out_features=10)

例：迁移学习（加载预训练参数）

如果想用 ImageNet 预训练权重 来提升收敛速度和准确率，可以改为：

from torchvision.models import VGG16_Weights

model1 = torchvision.models.vgg16(weights=VGG16_Weights.IMAGENET1K_V1)
# 冻结特征层参数
for param in model1.features.parameters():
    param.requires_grad = False

# 修改最后一层分类器
model1.classifier[6] = nn.Linear(4096, 10)

:::note 这样，模型只会训练最后几层，全卷积层保持 ImageNet 学到的通用特征，适合小数据集。 :::

保存模型

VGG16_MODEL = torchvision.models.vgg16(weights = None)

# 保存整个模型（不推荐做法）
torch.save(VGG16_MODEL, "./My_Model/VGG16_no_weights_All_Model.pth")

# 仅保存模型参数（推荐做法）
torch.save(VGG16_MODEL.state_dict(), "./My_Model/VGG16_no_weights_state_dict.pth")

使用模型

# 直接加载整个模型（不推荐做法）
model = torch.load("./My_Model/VGG16_no_weights_All_Model.pth", weights_only = False)
print(model)
  
# 仅加载模型参数（推荐做法）
model = torchvision.models.vgg16(weights = False)  
model.load_state_dict(torch.load("./My_Model/VGG16_no_weights_state_dict.pth"))
print(model)

配置 Conda + Pytorch + d2l 环境

Sun, 05 Oct 2025 00:00:00 GMT

软件安装

Anaconda官网下载，或者按照该博客来安装下载安装下载
Vscode官网下载，或者按照该博客来安装下载
也可按照该视频配置

环境配置

:::note 如果想要使用GPU进行深度学习模型的训练，就需要安装CUDA，我用的是Nvidia的GPU. :::

安装CUDA以及cudnn

检查自己电脑支持的CUDA版本：打开cmd执行.

nvidia-smi

前往官网下载自己电脑支持版本的 CUDA ，我选择12.8.0版本.

下载时选择自定义，勾选下载全部选项，并记住安装路径.

检验是否安装成功：打开cmd执行.

nvcc -V

前往官网下载对应版本的 cudnn 压缩包，后进行解压，我选择8.9.7版本.
进入指定目录（上文记住的安装路径），如C:\Program Files\NVIDIA GPU Computing Toolkit\CUDA\v12.8，将bin，include，lib三个文件夹拖入进行替换.<br><br>

创建虚拟环境并配置pytorch

打开Anaconda Prompt，创建环境：

conda create -n ENV_NAME python=3.9

激活环境：

conda activate ENV_NAME

查看环境是否创建成功：

conda env list

安装Pytorch命令复制网址： https://pytorch.org/get-started/locally 选择自己版本的选项，在环境激活的情况下，复制命令并安装.

:::note 下载的包会比较大，如我的是3.5G，如比较小可能不是安装的GPU版本 :::

创建.py文件，并将conda中刚刚安装环境中的python作为解释器，具体教程看:

运行下列代码，不报错即安装成功:

import torch
print(torch.__version__)
print(torch.cuda.is_available())

退出环境：

conda deactivate

删除环境：

conda remove --name ENV_NAME --all

软件配置

Jupyter Notebook

打开Anaconda Prompt，激活环境后，执行：

pip install jupyter

下载完后，执行，查看Jupyter的配置路径，只需看到路径，终端中输入 "N" 即可：

jupyter notebook --generate-config

进入路径，打开 "jupyter_notebook_config" 文件，搜索：

The directory to use

修改如下：

    ## The directory to use for notebooks and kernels.
    #  Default: ''
-   # c.ServerApp.root_dir = ''
+   c.ServerApp.root_dir = '默认打开路径'

打开Anaconda Prompt，激活环境后，执行：

conda install ipykernel

将环境写入内核：

python -m ipykernel --user --name 你创建环境的名字 --display-name "你创建环境的名字"

d2l库安装

打开Anaconda Prompt，激活环境后，执行：

pip install d2l

运行下列代码，不报错即安装成功:

import torch
from d2l import torch as d2l

圆形LED点阵屏幕

Tue, 11 Feb 2025 00:00:00 GMT

2月11日更新

在刷Youtube的时候看到了一个大佬做出的开源项目，简单来说就是用led贴片贴出来一个小屏幕，觉得很有意思。但虽说是开源的，但是资料并不完全，就想着自己从头开始把他复刻一遍，正好寒假里时间充裕，也算是自己做的第一个小项目。

具体的链接如下：https://mitxela.com/projects/fluid-pendant

由于我打算做出来的点阵屏幕有点小，并且只用两层板来打样，所以发现用74HC595这个芯片好像位置不太够，再加上想在这块板子上加上控制芯片和mpu6050来实现一些好玩的效果，就去搜了搜有没有用很少IO口就能控制很多LED灯的方法，还真有。

方法的名字叫做“查理复用”（Charlieplexing），是一种LED显示器多路复用的方法，主要使用到了IO口输出的三种状态：高电平、低电平，高阻态。

所谓“高阻态”，是指GPIO对外部电路表现出极大的阻抗。因阻抗很大，几乎不会吸入电流，也不会对外输出电流。而我们就可以让其中两个IO口分别呈现高低电平，而其他的所有都为高阻态的方式，来实现对led的控制。具体的化简电路图如下：

比如我想让 LED5 亮起，就给 GPIO_1 低电平，GPIO_2 高阻态，GPIO_3 高电平就能实现。这样算下来，n个IO口就能控制n*(n+1)个LED灯，可以大大节省IO口的资源。但是一个时间只能亮一个LED灯，所以需要用到视觉暂留原理，让每一行的每一个LED灯快速的亮起又灭掉，采用逐行扫描的方法，一次扫描完所有LED灯的频率大于60HZ，就能实现在我们看来很多灯在同一时刻亮的现象，但这同时也需要对控制芯片的时钟要求比较高。

PCB

首先需要解决LED灯布线的问题，想到了一种方法，如下图所示：

通过对角线这样的走线方法，能够实现用16个IO口控制240（15*16）个led灯，且能保证布线不会很混乱，每一条总线都是斜向上或者斜向下，与其他总线平行的排布。由于要排成圆形的阵列，我删去了一些LED灯，最后留下了208个，最为最终的排列，如下图所示：

把这张原理图转换到PCB图，并且排列好，连好线，如下图所示：

这样的连线可以为主控的放置节省非常多的空间，背面只存在一些过孔，非常NICE。

随后就是绘制主控的电路图了，最后还是选择 Stm32f103c8t6 ，芯片比较小，算力也够。从网上随便扒了个原理图复制下来，画了PCB，如下图所示：

之后想了想，发现不需要自己焊mpu6050，直接用现成的模块就可以了，还方便且不容易出错，稍微改动了一下PCB，并且把引出的引脚焊盘都扩大了一点，如下图所示:

顺便把钢网也开了

2月28日更新

终于，在一万年后，我终于终于终于把这块板子焊好了，实物图如下，并进行了上机检测，在keil中可以识别到芯片，WIN!

3月1日更新

测试了一下焊完的电路，发现了原本电路图中的两处问题，问题修改后如下图所示，LED灯正负反转一下是最简单的解决方法，具体更合理的优化到之后再改一改。

3月2日更新

本来想着之后慢慢弄，但转念一想，干都干了，不如今天把大部分事情都搞完，随后就开始在keil中写屎山了··· 感觉之后写一个上位机会方便很多，但这都是后话了···

高低电平采用推挽输出，高阻态只需要将引脚模式改成输入就可以了。每次初始化亮一个灯，通过频率非常高的切换，让我们的眼睛看起来全都在亮。之后又发现总有两条斜线的灯不亮QAQ，红温了

经过排查之后发现是PB3和PB4这两个引脚在上电后默认配置为JTAG功能，如若需要恢复正常的输入输出模式，需要添加GPIO的复用。之后就又是枯燥的复制粘贴写代码

至此，这个小项目最基础的部分已经完成了，已经可以做一些小的屏幕展示。之后会继续在mpu6050模块的基础上开发一些更好玩的东西: )

5月13日更新

好久没推进这个项目了，实在是有点忙，出来冒个泡，顺便把项目开源了 :)

https://github.com/Adrian-Pierre/LED_Project

Anpier

远程服务器用 aliyunpan 备份 checkpoints

准备 aliyunpan

建备份目录

打包 checkpoints

上传

RSRefSeg2 环境搭建与实验复现（RTX A800）

下载并安装 Miniconda

创建干净环境（Python 3.10）

安装 A800 的 PyTorch

安装 MMCV2.2.x

安装其他依赖项

拉取 RSRefSeg 2 工程

下载 RefSegRS 数据集

下载 RRSIS-D 数据集

下载官方 checkpoint

Refsegrs

RRSIS-D

验证实验

Refsegrs

RRSIS-D

SAMWISE 环境搭建与实验复现（RTX 5090）

下载并安装 Miniconda

创建干净环境（Python 3.10）

安装 RTX5090 必须的 PyTorch（Nightly cu128）

验证 GPU 是否正确支持

拉取 SAMWISE 工程

安装依赖

快速 sanity check

下载Ref-DAVIS17数据集

下载 Ref-DAVIS17 Model

验证 Ref-DAVIS17 实验数据

aerial-d 环境搭建与实验复现（RTX 5090）

下载并安装 Miniconda

创建干净环境（Python 3.12）

安装 RTX5090 必须的 PyTorch（Nightly cu128）

验证 GPU 是否正确支持

拉取 SAMWISE 工程

安装依赖

快速 check

下载数据集

下载 checkpoint

验证实验数据

Cloudflare Turnstile 为静态博客添加「无感」人机验证

Cloudflare 就是神，不接受反驳

创建 Turnstile 组件

在 Pages 中配置 Secret Key

创建 gate 页面（前端）

服务端校验 Turnstile（Pages Functions）

全站拦截（Middleware）

部署与测试

测试流程

威联通 NAS + ROG 八爪鱼 + Nextcloud：家庭私有网盘

前言

我的网络与硬件环境

Nextcloud 应用拉取

初始化 Nextcloud

路由器配置 DDNS

添加 WireGuard VPN 服务

总结

配置 Vscode + Git + Github

Github 注册

下载 Vscode

下载 & 安装 Git

配置 Git

Push 至 Github

ESP32 + 自己编写的组件陈列

板载 RGB

board_rgb

下载官方 RGB 组件

添加组件

在 main.c 中使用

GPIO 初始化重写

gpio_setup

添加组件

在 main.c 中使用

u8g2库 点亮 OLED

修改 main\idf_component.yml

在 main.c 中使用

OLED 0.96寸 函数封装

u8g2库点亮 OLED

修改 `main\idf_component.yml`

OLED 0.96寸函数封装

安装/更新 `rehype-external-links`

修改 `astro.config.mjs`