polar-bear～Blog

BTRFS与Timeshift

2026-05-10T16:53:47.355Z

安装

https://www.wooveep.com/posts/ubuntu-desktop24.04-use-btrfs/

更新initramfs和GRUB

安装了BTRFS后，若更换磁盘导致id变化，需要重新生成initramfs和GRUB。

例如，调整efi分区。

找不到设置的磁盘分区导致超时90s.

[   13.099878] input: sof-hda-dsp HDMI/DP,pcm=5 as /devices/pci0000:00/0000:00:1f.3/skl_hda_dsp_generic/sound/card0/input28
[   13.122121] i915 0000:00:02.0: [drm] Selective fetch area calculation failed in pipe A
[  100.252860] audit: type=1400 audit(1778418880.812:2): apparmor="STATUS" operation="profile_load" profile="unconfined" name=4D6F6E676F444220436F6D70617373 pid=1676 comm="apparmor_parser"
[  100.252883] audit: type=1400 audit(1778418880.812:3): apparmor="STATUS" operation="profile_load" profile="unconfined" name="balena-etcher" pid=1681 comm="apparmor_parser"
[  100.252909] audit: type=1400 audit(1778418880.812:4): apparmor="STATUS" operation="profile_load" profile="unconfined" name="buildah" pid=1685 comm="apparmor_parser"
[  100.252931] audit: type=1400 audit(1778418880.812:5): apparmor="STATUS" operation="profile_load" profile="unconfined" name="QtWebEngineProcess" pid=1677 comm="apparmor_parser"
[  100.252965] audit: type=1400 audit(1778418880.812:6): apparmor="STATUS" operation="profile_load" profile="unconfined" name="1password" pid=1674 comm="apparmor_parser"

使用ubuntu安装盘进入’安装或试用‘Live 环境。

创建挂载点并挂载子卷

# 创建挂载点目录
sudo mkdir -p /mnt/ubuntu

# 挂载 btrfs 根子卷 @
sudo mount -t btrfs -o subvol=@ /dev/nvme0n1p6 /mnt/ubuntu

# 验证挂载是否成功（应该看到 /mnt/ubuntu 下有 bin, etc, home 等目录）
ls /mnt/ubuntu

挂载 EFI 分区

1 2	# 挂载 EFI 分区到 /boot/efi(根据fstab查看对应分区) sudo mount /dev/nvme0n1p1 /mnt/ubuntu/boot/efi

挂载虚拟文件系统

# 挂载必要的系统目录
sudo mount --bind /dev /mnt/ubuntu/dev
sudo mount --bind /proc /mnt/ubuntu/proc
sudo mount --bind /sys /mnt/ubuntu/sys

# 绑定 efivars（用于 UEFI 引导修复）
sudo mount --bind /sys/firmware/efi/efivars /mnt/ubuntu/sys/firmware/efi/efivars 2>/dev/null || true

进入 chroot 环境

1	sudo chroot /mnt/ubuntu

在 chroot 中重新生成 initramfs 和 GRUB

# 重新生成 initramfs
update-initramfs -u

# 重新安装 GRUB（UEFI 方式）
grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=Ubuntu --recheck

# 更新 GRUB 配置
update-grub

# 退出 chroot
exit

# 卸载所有挂载
sudo umount -R /mnt/ubuntu

# 重启系统（记得拔掉 U 盘）
sudo reboot

Onedrive下载

2026-03-06T17:10:03.616Z

rclone

在终端

1
2
3

wget https://downloads.rclone.org/v1.73.2/rclone-v1.73.2-linux-amd64.zip
unzip rclone-v1.73.2-linux-amd64.zip
./rclone-v1.73.2-linux-amd64/rclone config

输入 n (New remote)。
名字随便起，比如 onedrive。
Type 选择 onedrive (输入数字即可，通常是41，41 / Microsoft OneDrive\ (onedrive))。
client_id 和 client_secret 直接留空（回车）。
region，一般E5 账号都是 Global 国际版，选1即可
tenant，直接跳过，这是给服务主体/Service Principal 用的，普通 E5 账号登录不需要填这个
Edit advanced config? 选 n。
关键点： Use auto config? 选y使用浏览器登陆，没有浏览器使用n，粘贴token
token：填入下面获取的token
config_type：选择1， OneDrive 个人或商业版
config_driveid：会列出你账户下面的OneDrive默认即可
Found drive … -> 选 y
Keep this … remote? -> 选 y。
最后输入 q退出。

复制配置文件

在本地按照上面的方法配置好后，可以直接

1	rclone config show

你会看到一段类似下面的内容，完整复制它（包括 [onedrive] 那一行）：

[onedrive]
type = onedrive
token = {"access_token":"eyJh...（超级长）...","token_type":"Bearer","refresh_token":"...","expiry":"..."}
drive_id = b!.......
drive_type = business

拷贝这个配置文件到服务器

mkdir -p ~/.config/rclone/

## 编辑或者直接拷贝文件
nano ~/.config/rclone/rclone.conf

## 检查验证配置
rclone lsd onedrive:

获取token

在本地同样下载rclone

1	rclone authorize "onedrive"

在弹出的web页面授权onedrive登陆，之后即可获得access_token。

获取{}包裹的完整token后，可以到上面进行认证。

下载

# 语法: rclone copy 源路径 本地路径 [参数]
# -P: 显示实时进度。
# --transfers=16: 同时下载 16 个文件
# --multi-thread-streams=4: 大文件会分成 4 个线程并发下载
# --buffer-size=64M: 增加内存缓存，减少 IO 瓶颈。

rclone copy onedrive:/你的文件夹/ /home/download/ \
  -P \
  --transfers=16 \
  --buffer-size=64M \
  --multi-thread-streams=4

D-FINE--基于Transformer架构的实时目标检测模型

2026-03-01T23:19:31.956Z

D-FINE

D-FINE 是一个强大的实时目标检测器，将 DETR 中的边界框回归任务重新定义为了细粒度的分布优化（FDR），并引入全局最优的定位自蒸馏（GO-LSD），在不增加额外推理和训练成本的情况下，实现了卓越的性能。

Peterande/D-FINE: D-FINE: Redefine Regression Task of DETRs as Fine-grained Distribution Refinement [ICLR 2025 Spotlight]

数据集-OpenDataLab

D-FINE 论文理解_dfine-CSDN博客

D-FINE：实时目标检测的“速度与激情”，精准又高效！ - 知乎

训练

数据集准备

准备数据集

import json
import random
import xml.etree.ElementTree as ET
from pathlib import Path

IMG_EXTS = [".jpg", ".jpeg", ".png", ".bmp", ".webp"]

# ==========================
# Hardcoded runtime settings
# ==========================
SETTINGS = {
    "images_dir": "coco/images",
    "xml_dir": "coco/Annotations",
    "output_dir": "coco/converted",
    "train_ratio": 0.8,
    "val_ratio": 0.1,
    "test_ratio": 0.1,
    "seed": 42,
}


def parse_xml(xml_path: Path):
    root = ET.parse(xml_path).getroot()
    filename = (root.findtext("filename") or "").strip()
    size = root.find("size")
    if size is None:
        return None

    w = int(float(size.findtext("width", default="0")))
    h = int(float(size.findtext("height", default="0")))
    if w <= 0 or h <= 0:
        return None

    objs = []
    for obj in root.findall("object"):
        name = (obj.findtext("name") or "").strip()
        box = obj.find("bndbox")
        if not name or box is None:
            continue

        xmin = float(box.findtext("xmin", default="0"))
        ymin = float(box.findtext("ymin", default="0"))
        xmax = float(box.findtext("xmax", default="0"))
        ymax = float(box.findtext("ymax", default="0"))
        if xmax <= xmin or ymax <= ymin:
            continue
        objs.append((name, xmin, ymin, xmax, ymax))

    if not objs:
        return None
    return filename, w, h, objs


def find_img(images_dir: Path, stem: str):
    for ext in IMG_EXTS:
        p = images_dir / f"{stem}{ext}"
        if p.exists():
            return p
    return None


def to_coco(samples, cls2id):
    images, annotations = [], []
    ann_id = 1
    for img_id, s in enumerate(samples, start=1):
        images.append({
            "id": img_id,
            "file_name": s["file_name"],
            "width": s["width"],
            "height": s["height"],
        })
        for cls_name, xmin, ymin, xmax, ymax in s["objects"]:
            w = xmax - xmin
            h = ymax - ymin
            annotations.append({
                "id": ann_id,
                "image_id": img_id,
                "category_id": cls2id[cls_name],
                "bbox": [xmin, ymin, w, h],
                "area": w * h,
                "iscrowd": 0,
            })
            ann_id += 1

    categories = [
        {"id": cid, "name": name, "supercategory": "object"}
        for name, cid in sorted(cls2id.items(), key=lambda x: x[1])
    ]
    return {"images": images, "annotations": annotations, "categories": categories}


def dump_json(path: Path, data):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8")


def dump_lines(path: Path, lines):
    path.parent.mkdir(parents=True, exist_ok=True)
    path.write_text("\n".join(lines) + "\n", encoding="utf-8")


def main():
    if abs(SETTINGS["train_ratio"] + SETTINGS["val_ratio"] + SETTINGS["test_ratio"] - 1.0) > 1e-6:
        raise ValueError("train/val/test ratio sum must be 1.0")

    images_dir = Path(SETTINGS["images_dir"]).resolve()
    xml_dir = Path(SETTINGS["xml_dir"]).resolve()
    out_dir = Path(SETTINGS["output_dir"]).resolve()

    xml_files = sorted([p for p in xml_dir.glob("*.xml") if not p.name.startswith(".")])
    if not xml_files:
        raise FileNotFoundError(f"No xml files found in {xml_dir}")

    samples = []
    cls_names = set()
    skipped = 0

    for xp in xml_files:
        parsed = parse_xml(xp)
        if parsed is None:
            skipped += 1
            continue

        filename, w, h, objs = parsed
        stem = Path(filename).stem if filename else xp.stem
        img_path = find_img(images_dir, stem)
        if img_path is None:
            skipped += 1
            continue

        cls_names.update([o[0] for o in objs])
        samples.append({
            "file_name": img_path.name,
            "width": w,
            "height": h,
            "objects": objs,
            "abs_path": img_path.as_posix(),
        })

    if not samples:
        raise RuntimeError("No valid samples generated")

    cls2id = {name: i for i, name in enumerate(sorted(cls_names))}

    random.Random(SETTINGS["seed"]).shuffle(samples)
    n = len(samples)
    n_train = int(n * SETTINGS["train_ratio"])
    n_val = int(n * SETTINGS["val_ratio"])

    train = samples[:n_train]
    val = samples[n_train:n_train + n_val]
    test = samples[n_train + n_val:]

    ann_dir = out_dir / "annotations"
    split_dir = out_dir / "splits"

    dump_json(ann_dir / "train.json", to_coco(train, cls2id))
    dump_json(ann_dir / "val.json", to_coco(val, cls2id))
    dump_json(ann_dir / "test.json", to_coco(test, cls2id))

    dump_lines(split_dir / "train.txt", [x["abs_path"] for x in train])
    dump_lines(split_dir / "val.txt", [x["abs_path"] for x in val])
    dump_lines(split_dir / "test.txt", [x["abs_path"] for x in test])

    ultralytics_yaml = out_dir / "ultralytics_data.yaml"
    ultralytics_yaml.write_text(
        "\n".join([
            f"train: {(split_dir / 'train.txt').as_posix()}",
            f"val: {(split_dir / 'val.txt').as_posix()}",
            f"test: {(split_dir / 'test.txt').as_posix()}",
            f"nc: {len(cls2id)}",
            f"names: {[name for name, _ in sorted(cls2id.items(), key=lambda x: x[1])]}",
        ]) + "\n",
        encoding="utf-8",
    )

    summary = {
        "images_total": n,
        "train": len(train),
        "val": len(val),
        "test": len(test),
        "classes": sorted(cls_names),
        "num_classes": len(cls_names),
        "skipped_files": skipped,
        "output_dir": out_dir.as_posix(),
    }
    dump_json(out_dir / "summary.json", summary)
    print(json.dumps(summary, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()

创建自定义配置文件

# 单目标 volleyball 实验配置：S 模型 + Objects365 预训练迁移
# 用法（在 D-FINE 目录下执行）：
# python train.py -c ../config/volleyball_s_transfer.yml --use-amp --seed 0 -t weights/dfine_s_obj365.pth

__include__: [
  '../D-FINE/configs/dfine/custom/objects365/dfine_hgnetv2_s_obj2custom.yml',
]

# 实验输出目录（相对 D-FINE 工作目录）
output_dir: ./output/exp_s_transfer_obj_aug

# 数据集设置：单类别，且不做 COCO80 类别重映射
num_classes: 1
remap_mscoco_category: False

# ============ 数据增强配置 ============
# 启用更激进的数据增强来改进小数据集性能
train_dataloader:
  collate_fn:
    # 多尺度训练
    base_size: 640
    base_size_repeat: 10
    stop_epoch: 56
    ema_restart_decay: 0.9999
    type: BatchImageCollateFunction
  dataset:
    img_folder: C:/Users/Rick/Desktop/python/ObjectDetection/coco/images
    ann_file: C:/Users/Rick/Desktop/python/ObjectDetection/coco/converted/annotations/train.json
    return_masks: False
    type: CocoDetection
  drop_last: True
  num_workers: 4
  shuffle: True
  total_batch_size: 32
  type: DataLoader


val_dataloader:
  collate_fn:
    type: BatchImageCollateFunction
  dataset:
    img_folder: C:/Users/Rick/Desktop/python/ObjectDetection/coco/images
    ann_file: C:/Users/Rick/Desktop/python/ObjectDetection/coco/converted/annotations/val.json
    return_masks: False
    # 验证集使用最小增强
    transforms:
      type: Compose
      ops:
        # 只进行必需的变换，不做随机增强
        - type: Resize
          size: [640, 640]
        - type: ConvertPILImage
          dtype: float32
          scale: True
        - type: ConvertBoxes
          fmt: cxcywh
          normalize: True
    type: CocoDetection
  drop_last: False
  num_workers: 4
  shuffle: False
  total_batch_size: 64
  type: DataLoader

# 每 N 轮额外保存一次 checkpointxxxx.pth（last/best 仍会按训练逻辑保存）
checkpoint_freq: 6  # 从12改为6，保存更频繁

# 训练总轮次
epochs: 160  # 从120增加到160，更长的训练

# ========== 额外优化参数 ==========
# 学习率预热
lr_warmup_scheduler:
  type: LinearWarmup
  warmup_duration: 500  # 预热500步

# EMA模型平滑
ema:
  type: ModelEMA
  decay: 0.9999
  start: 0
  warmups: 2000

# 梯度裁减
clip_max_norm: 0.1

# 同步批归一化（多卡训练）
sync_bn: True

训练

参考51hhh/D-FINE_train: D-FINE 自定义配置训练

-r (resume) 和 -t (tuning)

-r (resume)	恢复全部状态：模型权重 + 优化器 + last_epoch + lr_scheduler
-t (tuning)	只加载模型权重，epoch 从 0 开始，优化器全新

	-r (resume)	-t (tuning)
模型权重	加载	加载
优化器状态	恢复	全新
last_epoch	恢复 (=58)	从 -1 开始
lr_scheduler	恢复旧状态	全新
EMA 状态	恢复	全新

load_tuning_state() line 249-274 的逻辑：

def load_tuning_state(self, path):
    # 1. 加载 checkpoint
    state = torch.load(path)
    pretrain_state_dict = state["ema"]["module"]

    # 2. 尝试调整 head 参数（处理 num_classes 不匹配）
    adjusted_state_dict = self._adjust_head_parameters(
        module.state_dict(), pretrain_state_dict
    )

    # 3. 形状匹配的参数全部加载，不匹配的跳过
    stat, infos = self._matched_state(module.state_dict(), adjusted_state_dict)
    module.load_state_dict(stat, strict=False)

关键：_adjust_head_parameters 只在 num_classes 不同时才调整/丢弃检测头。

注意按照机器核心调整num_workers，以便达到最佳性能。

开始训练

cd D-FINE

python train.py -c ../config/volleyball_s_transfer.yml --use-amp --seed 0 -t weights/dfine_s_obj365.pth
python train.py -c ../config/volleyball_s_transfer.yml --use-amp --seed 0 -r output/exp_s_transfer/last.pth

+ -c 接config配置文件路径
 + -t 从预训练模型路径迁移tuning
 + -r 从last模型开始继续训练resume

分析和评估

分析

对于单目标排球训练，使用900张少量数据集迁移。

exp_s_transfer：obj365预训练模型迁移
exp_s_transfer_obj_aug：obj预训练模型+数据增强
exp_s_transfer_obj2coco_aug：obj2coco预训练模型+数据增强

`Test/coco_eval_bbox_0`（Precision：AP50:95-all）
`Test/coco_eval_bbox_1`（Precision：AP50）
`Test/coco_eval_bbox_2`（Precision：AP70）
`Test/coco_eval_bbox_3`（Precision：0.50:0.95-small）
`Test/coco_eval_bbox_4`（Precision：0.50:0.95-medium）
`Test/coco_eval_bbox_5`（Precision：0.50:0.95-large）  
`Test/coco_eval_bbox_6`（Recall：0.50:0.95-all-maxDets=1）
`Test/coco_eval_bbox_7`（Recall：0.50:0.95-all-maxDets=10）
`Test/coco_eval_bbox_8`（Recall：0.50:0.95-all-maxDets=100）
`Test/coco_eval_bbox_9`（Recall：0.50:0.95-small-maxDets=100）
`Test/coco_eval_bbox_10`（Recall：0.50:0.95-medium-maxDets=100）
`Test/coco_eval_bbox_11`（Recall：0.50:0.95-large-maxDets=100）

收敛：蓝色曲线的 AP（coco_eval_bbox_0）在大约 60 个 Epoch 前迅速上升，随后进入平台期

红色曲线 exp_s_transfer_obj_aug 前期训练loss抖动，而且AP/AR无法快速上升（后续没啥问题，都能用），疑似数据集过小问题，停止训练。obj 数据集里确实有“排球”这个类别（Class 240），但是COCO 的标注更为精准，且包含大量小目标。obj2coco数据集的质量和多样性更好。（~~官方说Objects365 预训练模型泛化性最好，其实差不多，感觉Objects365+COCO更好~~）

无法收敛：橙黄色曲线 exp_s_transferobj365预训练模型，在训练了120Epoch后依旧无法收敛，表明900+数据集过小。

小目标缺失： coco_eval_bbox_3/9（代表 Small 尺寸的 AP/AR）。表示数据集中没有配置好小目标。

Loss 曲线在现代优化器（如 AdamW + Cosine Annealing）的加持下，通常都会表现良好，一般数据集没有问题，不会出现问题。主要查看AP/AR曲线即可。

数据集标注错误问题

标注数据集没有紧密贴合物体，模型无法正确收敛。

预训练模型迁移和从零开始对比

exp_s_transfer_objtococo_aug_2000为在obj2coco模型迁移微调，exp_s_transfer_aug_2000为从零开始训练，收敛需要更长时间。

查询过激活

术语	含义
Query Over-Activation（查询过激活）	DETR 系列中，预训练的 learned queries 在微调后仍保留对非目标物体的定位能力，导致错误激活
False Activation（假激活）	D-FINE Issue #277 中使用的原词，指模型对非目标物体产生高置信度检测
Objectness-Classification Conflation	目标性与分类的混淆——单类分类头退化为"是否有物体"而非"是否是目标类别"
Class Collapse（类别坍缩）	多类预训练模型微调为单类后，分类维度坍缩，丧失类别区分能力

DETR 系列架构（D-FINE / RT-DETR）

D-FINE 基于 RT-DETR 改进，属于 DETR（DEtection TRansformer）家族。核心架构：

输入图像
  │
  ▼
┌──────────────┐
│   Backbone   │  HGNet-v2 (特征提取)
│  (Encoder)   │
└──────┬───────┘
       │  多尺度特征图
       ▼
┌──────────────┐
│  Hybrid      │  高效混合编码器
│  Encoder     │  (特征融合 + 自注意力)
└──────┬───────┘
       │
       ▼
┌──────────────────────────────────┐
│      Transformer Decoder         │
│                                  │
│  300 个 Learned Object Queries   │ ◄── 问题根源
│         ×                        │
│  Cross-Attention (查询 × 特征)   │
│         ×                        │
│  6 层 Decoder Layer              │
└──────────┬───────────────────────┘
           │
     ┌─────┴─────┐
     ▼           ▼
┌─────────┐ ┌──────────┐
│ 分类头   │ │  回归头   │
│ scores  │ │  boxes   │
│ labels  │ │ (x1,y1,  │
│         │ │  x2,y2)  │
└─────────┘ └──────────┘

D-FINE 使用 300 个可学习的查询向量（query embeddings）
每个 query 在训练过程中"专攻"检测特定位置和类型的物体
在 COCO 预训练中，这 300 个 query 学会了定位 80 类物体（人、车、椅子、球…）
推理时，每个 query 通过 cross-attention 与图像特征交互，输出一个检测结果

D-FINE输出层（单类）

P(class_i | query_j) = softmax([logit_volleyball, logit_no_object])

其中 softmax 只有两个类别：
  logit_volleyball  → "是排球"
  logit_no_object   → "没有目标"

对于非排球物体（如人）：
  query 的 cross-attention 被物体特征强激活
  logit_volleyball 被推高（因为query认为"这里有东西"）
  logit_no_object 被压低
  P(volleyball) ≈ 0.85  → 超过阈值，误检！

解决方法：

方案 A：空标注图片加入训练Issue #277必须打 Issue #247 补丁防止死锁
方案 B：训练策略调整

参数	当前值	建议值	说明
预训练权重	Obj365+COCO	无 / 仅 Objects365	单类简单场景从头训更好
`eos_coefficient`	0.1（默认）	0.3-0.5	增大 no-object 损失权重，抑制假激活
`num_queries`	300	50-100	减少 query 数量，降低过激活概率
学习率	-	transformer 1e-4, backbone 1e-5	过高导致训练崩溃
`auxiliary_loss`	-	`True`	每层 decoder 都加监督，学会正确的目标数量

方案 C：Denoising 区域负样本

Issue #277

原理：利用 D-FINE 已有的 contrastive denoising 机制，在非目标区域注入负样本，强制 query 学会抑制。不需要额外数据，但需要修改 src/zoo/dfine/denoising.py。

空标注微调

添加空标注图片样本作为负样本。

从左上，右上，左下，右下依次为：

exp_s_finetune_neg_aug exp_s_finetune_neg_objtococo_aug

exp_s_transfer_aug_2000 exp_s_transfer_objtococo_aug_2000

┌────────────────────────────┬──────────┬────────────┬───────────┬───────────┬───────────┬────────┬────────────┐
│            模型            │  预训练  │ 负样本微调 │ FPPI @0.3 │ FPPI @0.5 │ FPPI @0.7 │ Max FP │ Clean @0.3 │
├────────────────────────────┼──────────┼────────────┼───────────┼───────────┼───────────┼────────┼────────────┤
│ transfer_aug               │ obj      │ 否         │ 2.15      │ 0.83      │ 0.33      │ 0.930  │ 0%         │
├────────────────────────────┼──────────┼────────────┼───────────┼───────────┼───────────┼────────┼────────────┤
│ transfer_objtococo_aug     │ obj+coco │ 否         │ 1.11      │ 0.48      │ 0.32      │ 0.938  │ 27.7%      │
├────────────────────────────┼──────────┼────────────┼───────────┼───────────┼───────────┼────────┼────────────┤
│ finetune_neg_aug           │ obj      │ 是         │ 2.36      │ 0.68      │ 0.22      │ 0.885  │ 0%         │
├────────────────────────────┼──────────┼────────────┼───────────┼───────────┼───────────┼────────┼────────────┤
│ finetune_neg_objtococo_aug │ obj+coco │ 是         │ 0.93      │ 0.45      │ 0.18      │ 0.925  │ 36.6%      │
└────────────────────────────┴──────────┴────────────┴───────────┴───────────┴───────────┴────────┴────────────┘

FPPI @阈值（False Positives Per Image）	在置信度阈值下，平均每张背景图的误检数量
Max FP（最大误检置信度）	所有背景图中，最严重误检的置信度值
Clean @阈值（干净图片比例）	在置信度阈值下，完全没有任何误检的背景图占比

                  obj365 路线          obj2coco 路线
                  ──────────          ─────────────
无负样本:          2.15 FPPI           1.11 FPPI
                     ↓ 负样本微调         ↓ 负样本微调
有负样本:          2.36 FPPI (更差!)    0.93 FPPI (改善)

负样本微调有效，效果有限，原因是负样本只有101张，对于2000+数据集太少。

负样本微调让更多 query 的分数集中到 0.3-0.5区间，低置信度误检反而变多了，但高置信度误检减少了

DN随机负样本

在 denoising.py 中，在与图片原有目标没有交集的区域随机生成框，将其标签视为背景类参与分类损失

原理：利用 D-FINE 已有的 contrastive denoising 机制，在非目标区域注入负样本，强制 query 学会抑制。不需要额外数据，但需要修改 src/zoo/dfine/denoising.py。

参考51hhh/D-FINE_train at a285f6a7ab2cfa11bb381f0161289e0b4e83f876

每张图随机生成有限数量（如 50 个）的框
过滤掉与 GT 框重叠的（IoU > 0.3）
剩余框标记为 background 类（class_id = num_classes，即 padding index）
这些框只参与分类 loss（推向 no-object），不参与回归 loss
通过 DN 机制注入训练，无需额外数据

上图为exp_s_obj2coco_neg_d，下图为exp_s_obj2coco_neg_d_q100

┌───────────────────┬──────────┬──────────┬────────────────┬──────────┬──────────┬────────────────┐
│       模型        │   策略   │ FPPI@0.3 │ Clean Rate@0.3 │ Max Conf │ FPPI@0.5 │ Clean Rate@0.5 │
├───────────────────┼──────────┼──────────┼────────────────┼──────────┼──────────┼────────────────┤
│ obj2custom (基准) │ 无       │ 1.109    │ 27.7%          │ 0.938    │ 0.475    │ 58.4%          │
├───────────────────┼──────────┼──────────┼────────────────┼──────────┼──────────┼────────────────┤
│ finetune_neg_aug  │ 无D      │ 0.931    │ 36.6%          │ 0.925    │ 0.446    │ 60.4%          │
├───────────────────┼──────────┼──────────┼────────────────┼──────────┼──────────┼────────────────┤
│ neg_d             │ A+D      │ 0.040    │ 96.0%          │ 0.417    │ 0.000    │ 100%           │
├───────────────────┼──────────┼──────────┼────────────────┼──────────┼──────────┼────────────────┤
│ neg_d_q100        │ A+D+Q100 │ 0.050    │ 96.0%          │ 0.698    │ 0.010    │ 99.0%          │
└───────────────────┴──────────┴──────────┴────────────────┴──────────┴──────────┴────────────────┘

neg_d 最优的：

FPPI@0.3 = 0.040（相比基准 1.109 下降 96.4%）
Clean Image Rate@0.3 = 96%（几乎没有误检）
Max Confidence = 0.417（远低于其他模型的 0.9+）
FPPI@0.5 = 0.0（零高置信度误检）

添加bg_loss配置和训练中评估

exp_s_obj2coco_neg_d/对比exp_s_obj2coco_neg_d_bg2/

bg2添加了：

# ============ 背景 loss 权重（放大背景查询的 VFL loss 梯度）============
DFINECriterion:
  bg_loss_weight: 2.0

# ============ Over-Activation 训练中评估 ============
eval_overactivation: True
negative_img_dir: "../coco/images/negative_samples"
oa_conf_threshold: 0.3
oa_ap_tolerance: 0.005  # stg2 AP下降≤0.5%时，若OA改善则保存best_oa.pth跳过rollback

解决exp_s_obj2coco_neg_d实际部署依旧会存在误检测情况。（上图D-FINE Query Over-Activation Analysis (Negative Images)指标不对，训练exp_s_obj2coco_neg_d时候negative_samples已经存在训练集中，导致评估指标时候表现良好。）

！！！

注意negative_samples评估数据需要与训练中negative_samples不同，测评指标才具有参考价值。

Over-Activation 训练中评估开启后需要在test中对negative_samples数据集检验测评，因为oa保存best模型原因与训练不能并行，会导致每次epoch增加10s（具体取决于negative_samples大小和算力大小）

Test/oa_fppi — False Positives Per Image

每张负样本图的平均误检数（置信度 >= oa_conf_threshold）

值	含义
0.04	100 张背景图共 4 个误检，几乎无误检（生产级）
2.15	100 张背景图共 215 个误检，严重过激活

值域：0 → ∞
理想值：< 0.05
趋势期望：随训练持续下降

Test/oa_clean_rate — Clean Image Rate

完全无误检的负样本图片比例

值	含义
0.96	100 张中 96 张完全干净，4 张有误检
0.00	所有图片都有至少一个误检（最差情况）

值域：0.0 → 1.0
理想值：> 0.95
趋势期望：随训练持续上升

Test/oa_max_score — Max Detection Score

所有负样本图中最高的单个误检置信度

值	含义
0.417	最严重误检置信度 41.7%，用 0.5 阈值可完全过滤（安全）
0.930	最严重误检置信度 93%，模型对误检极度自信（危险）

值域：0.0 → 1.0
理想值：< 0.5
趋势期望：随训练持续下降

边界框质量

D-FINE 将边界框回归重新定义为概率分布的精细化过程，而非直接回归坐标：

传统 DETR：query → [x, y, w, h]（4个确定值）
D-FINE： query → [P(x), P(y), P(w), P(h)]（4个概率分布）
每个分布有 N 个离散 bin

这使得 D-FINE 的边界框质量更高

评估

主要查看COCO 评估指标能够准确判断模型情况。

D-FINE默认提供了模型在不同 IoU 阈值 和 目标尺寸 下的精度（Precision）和召回率（Recall）等参数。

IoU (Intersection over Union): 预测框与真实框的重叠度
AP (Average Precision): 精确率曲线下的面积。
AR (Average Recall): 召回率，即模型找全目标的能力。

术语	全称	含义	预测情况
TP	True Positive	真正例	模型说是正类，实际也是正类
TN	True Negative	真负例	模型说是负类，实际也是负类
FP	False Positive	假正例	模型说是正类，实际却是负类
FN	False Negative	假负例	模型说是负类，实际却是正类

精确率 (Precision)

定义： 在模型所有预测为正类的样本中，真正是对的占比

$$Precision = \frac{TP}{TP + FP}$$

高精确率 (High Precision)表示模型检测到10个目标，有9个是正确的，检测精准正确。可能在很有把握才识别，容易漏识别，即低Recall

召回率 (Recall)

定义： 在所有实际为正类的样本中，模型成功找出的占比

$$Recall = \frac{TP}{TP + FN}$$

高召回率 (High Recall)表示模型在10个真正目标中，检测到9个，很少漏检，可能过于自信，检测到假目标，即低Precision

精确率和召回率往往是此消彼长的（Trade-off），可以使用F1-Score 来平衡这两者

主要查看指标

AP @[ IoU=0.50:0.95 ] ：单个类别的平均精度,这是最重要的综合指标。它计算了 IoU 从 0.5 到 0.95（步长 0.05）的平均值：0.5:0.05:0.95

mAP @[ IoU=0.50:0.95 ] ：多个类别平均精度的平均值，模型检测各个class的AP的平均。

AP @[ IoU=50/75]：IoU 阈值为 X 时的 AP，预测框和真实框的 IoU > 0.5，就认为它是 TP，较为宽容，而75则更为严格，要求模型的预测框必须与真实框高度重合。

area=small/medium/large 测试集中目标大小得分

可视化

使用 fiftyone可视化。

import json
import sys
from collections import defaultdict
from pathlib import Path

import fiftyone as fo
import fiftyone.core.labels as fol
import torch
import torchvision.transforms as T
from PIL import Image
from tqdm import tqdm


# ==========================
# Hardcoded runtime settings
# ==========================
# 修改这里即可，无需命令行传参
SETTINGS = {
    "repo_dir": "./D-FINE",
    "config": "./config/volleyball_s_transfer.yml",
    "checkpoint": "./D-FINE/output/exp_s_transfer_obj2coco_aug/best_stg1.pth",  # 最新的最佳权重
    "img_root": "./coco/images",
    "ann_file": "./coco/converted/annotations/val.json",
    "dataset_name": "volleyball-val-s-b1",
    "eval_key": "eval",
    "device": "cuda:0",
    "input_size": 640,
    "conf_thres": 0.25,
    "limit": 0,  # 0 = all
    "overwrite": True,
    "no_app": False,
}


def load_dfine_model(repo_dir: Path, config_path: str, checkpoint_path: str, device: str):
    sys.path.insert(0, str(repo_dir.resolve()))
    from src.core import YAMLConfig

    safe_config_path = prepare_windows_readable_config(Path(config_path))
    try:
        cfg = YAMLConfig(str(safe_config_path), resume=checkpoint_path)
    finally:
        cleanup_temp_config(safe_config_path, Path(config_path))
    if "HGNetv2" in cfg.yaml_cfg:
        cfg.yaml_cfg["HGNetv2"]["pretrained"] = False

    try:
        checkpoint = torch.load(checkpoint_path, map_location="cpu", weights_only=True)
    except TypeError:
        checkpoint = torch.load(checkpoint_path, map_location="cpu")
    except Exception:
        checkpoint = torch.load(checkpoint_path, map_location="cpu")
    state = checkpoint["ema"]["module"] if "ema" in checkpoint else checkpoint["model"]
    cfg.model.load_state_dict(state, strict=False)

    model = cfg.model.deploy().to(device).eval()
    postprocessor = cfg.postprocessor.deploy().to(device).eval()
    return model, postprocessor


def prepare_windows_readable_config(config_path: Path) -> Path:
    """
    D-FINE's yaml loader opens files without explicit encoding.
    On Windows this can default to GBK and fail on UTF-8 comments.
    This helper creates a GBK-readable temporary copy in the same directory.
    """
    if not config_path.exists():
        raise FileNotFoundError(f"Config file not found: {config_path}")

    text = None
    for enc in ("utf-8-sig", "utf-8", "gbk"):
        try:
            text = config_path.read_text(encoding=enc)
            break
        except UnicodeDecodeError:
            continue
    if text is None:
        raise RuntimeError(f"Cannot decode config file: {config_path}")

    # Build an ASCII-only temporary config so both UTF-8 and GBK default decoders can read it.
    safe_text = text.encode("ascii", errors="ignore").decode("ascii")
    tmp_path = config_path.parent / f".fo_tmp_{config_path.stem}.yml"
    tmp_path.write_text(safe_text, encoding="utf-8")
    return tmp_path


def cleanup_temp_config(tmp_path: Path, original_config_path: Path):
    # Do not remove if it's exactly the original file path
    if tmp_path.resolve() == original_config_path.resolve():
        return
    try:
        if tmp_path.exists():
            tmp_path.unlink()
    except Exception:
        pass


def load_coco(ann_file: Path):
    data = json.loads(ann_file.read_text(encoding="utf-8"))
    images = data["images"]
    annotations = data["annotations"]
    categories = data["categories"]

    anns_by_image = defaultdict(list)
    for ann in annotations:
        anns_by_image[ann["image_id"]].append(ann)

    cat_id_to_name = {c["id"]: c["name"] for c in categories}
    return images, anns_by_image, cat_id_to_name


def clamp01(x):
    return max(0.0, min(1.0, x))


def coco_bbox_to_fo_detection(bbox_xywh, w, h, label, confidence=None):
    x, y, bw, bh = bbox_xywh
    nx = clamp01(x / w)
    ny = clamp01(y / h)
    nw = clamp01(bw / w)
    nh = clamp01(bh / h)
    kwargs = dict(label=label, bounding_box=[nx, ny, nw, nh])
    if confidence is not None:
        kwargs["confidence"] = float(confidence)
    return fol.Detection(**kwargs)


def xyxy_abs_to_fo_detection(box_xyxy, w, h, label, confidence):
    x1, y1, x2, y2 = box_xyxy
    x1 = clamp01(float(x1) / w)
    y1 = clamp01(float(y1) / h)
    x2 = clamp01(float(x2) / w)
    y2 = clamp01(float(y2) / h)
    bw = clamp01(x2 - x1)
    bh = clamp01(y2 - y1)
    return fol.Detection(
        label=label,
        bounding_box=[x1, y1, bw, bh],
        confidence=float(confidence),
    )


def unpack_predictions(pred_output):
    """
    Support both formats:
    1) deploy mode tuple: (labels, boxes, scores), each shape [B, Q, ...]
    2) training/eval mode list[dict]: [{'labels','boxes','scores'}, ...]
    Returns tensors for a single sample: labels_1d, boxes_2d, scores_1d
    """
    # deploy tuple
    if isinstance(pred_output, (tuple, list)) and len(pred_output) == 3 and torch.is_tensor(pred_output[0]):
        labels_b, boxes_b, scores_b = pred_output
        return labels_b[0], boxes_b[0], scores_b[0]

    # list of dicts
    if isinstance(pred_output, list) and len(pred_output) > 0 and isinstance(pred_output[0], dict):
        first = pred_output[0]
        return first["labels"], first["boxes"], first["scores"]

    raise TypeError(f"Unsupported prediction output type: {type(pred_output)}")


@torch.no_grad()
def run():
    cfg = SETTINGS
    repo_dir = Path(cfg["repo_dir"])
    img_root = Path(cfg["img_root"])
    ann_file = Path(cfg["ann_file"])

    if fo.dataset_exists(cfg["dataset_name"]):
        if cfg["overwrite"]:
            fo.delete_dataset(cfg["dataset_name"])
        else:
            raise RuntimeError(
                f"Dataset '{cfg['dataset_name']}' already exists. Set SETTINGS['overwrite']=True to replace it."
            )

    images, anns_by_image, cat_id_to_name = load_coco(ann_file)
    if cfg["limit"] and cfg["limit"] > 0:
        images = images[: cfg["limit"]]

    model, postprocessor = load_dfine_model(
        repo_dir, cfg["config"], cfg["checkpoint"], cfg["device"]
    )

    tfm = T.Compose(
        [
            T.Resize((cfg["input_size"], cfg["input_size"])),
            T.ToTensor(),
        ]
    )

    dataset = fo.Dataset(cfg["dataset_name"])

    for img_info in tqdm(images, desc="Building FiftyOne dataset"):
        image_id = img_info["id"]
        file_name = img_info["file_name"]
        width = img_info["width"]
        height = img_info["height"]
        image_path = img_root / file_name

        if not image_path.exists():
            # Skip missing files instead of hard failing
            continue

        sample = fo.Sample(filepath=str(image_path.resolve()))

        # Ground truth
        gt_dets = []
        for ann in anns_by_image.get(image_id, []):
            cat_id = ann["category_id"]
            label = cat_id_to_name.get(cat_id, str(cat_id))
            gt_dets.append(coco_bbox_to_fo_detection(ann["bbox"], width, height, label))
        sample["ground_truth"] = fol.Detections(detections=gt_dets)

        # Prediction
        image = Image.open(image_path).convert("RGB")
        tensor = tfm(image).unsqueeze(0).to(cfg["device"])
        orig_target_sizes = torch.tensor(
            [[width, height]], dtype=torch.float32, device=cfg["device"]
        )

        outputs = model(tensor)
        pred_output = postprocessor(outputs, orig_target_sizes)
        labels_t, boxes_t, scores_t = unpack_predictions(pred_output)

        labels = labels_t.detach().cpu().tolist()
        boxes = boxes_t.detach().cpu().tolist()
        scores = scores_t.detach().cpu().tolist()

        pred_dets = []
        for label_id, box, score in zip(labels, boxes, scores):
            if score < cfg["conf_thres"]:
                continue

            # Handle both 0-based and 1-based label id conventions
            if label_id in cat_id_to_name:
                label_name = cat_id_to_name[label_id]
            elif (label_id + 1) in cat_id_to_name:
                label_name = cat_id_to_name[label_id + 1]
            else:
                label_name = str(label_id)

            pred_dets.append(xyxy_abs_to_fo_detection(box, width, height, label_name, score))

        sample["predictions"] = fol.Detections(detections=pred_dets)
        dataset.add_sample(sample)

    results = dataset.evaluate_detections(
        "predictions",
        gt_field="ground_truth",
        eval_key=cfg["eval_key"],
        compute_mAP=True,
    )

    try:
        print(f"mAP: {results.mAP():.6f}")
    except Exception:
        print("mAP: unavailable")
    print(f"Dataset: {dataset.name}")
    print(f"Samples: {len(dataset)}")
    print("Use FiftyOne sidebar to inspect FP/FN and per-sample errors.")

    if not cfg["no_app"]:
        session = fo.launch_app(dataset)
        session.wait()


if __name__ == "__main__":
    run()

手工标注的数据集与实际目标边缘存在较大误差，实测模型识别得更为精准。可以更新数据集，再次训练使得AP继续上升。

可以将图片添加为负样本继续微调。

负样本微调

咕咕咕。。。

部署

咕咕咕。。。

Orin NX 的种种

2026-01-24T00:22:31.356Z

Orin NX

link

Nsight 系统 |NVIDIA 开发者

开始配置

NoMachine

Downloads – Download

1
2
3

sudo apt update
sudo apt upgrade -y
sudo dpkg -i nomachine_*_arm64.deb

配置启动

配置服务器以允许远程连接
1
sudo systemctl start nxserver
设置NoMachine为开机启动：
1
sudo systemctl enable nxserver

设置EGL Capture 为yes，这是NoMachine提供的一个屏幕捕获功能，主要用于改善在特定显示服务器环境下的远程桌面体验：

1	sudo /etc/NX/nxserver --eglcapture yes

该命令重启后生效，可使用以下命令二次确认，当出现EGL Capture has been enabled则表示该功能已写入配置文件。

if [ -f "/usr/lib/systemd/user/org.gnome.Shell@wayland.service" ] && grep -q "nxpreload.sh" "/usr/lib/systemd/user/org.gnome.Shell@wayland.service" && [ -f "/usr/share/applications/org.gnome.Shell.desktop" ] && grep -q "nxpreload.sh" "/usr/share/applications/org.gnome.Shell.desktop" && [ -f "/usr/NX/etc/node.cfg" ] && grep -q "EnableEGLCapture 1" "/usr/NX/etc/node.cfg"; then echo "EGL Capture has been enabled"; else echo "Not enabled"; fi

重启NoMachine服务:
1
sudo systemctl restart nxserver

重启

snap版本

刷机后snap版本是2.7.0，Jetson内核与snap2.7.0不兼容，所以用snap2.7.0安装chrome/firefox后，有问题

修复方法：回退到与 Jetson 兼容的旧版本 Snap

执行以下命令即可（安装Snap 2.68.5并锁定，使其不会被snap或apt更新）

snap download snapd --revision=24724
sudo snap ack snapd_24724.assert
sudo snap install snapd_24724.snap
sudo snap refresh --hold snapd

由于orin是arm架构因此无法安装x86 版本的chrome，只能安装 chromium，具体命令如下：

1
2
3

sudo add-apt-repository ppa:a-v-shkop/chromium
sudo apt-get update
sudo apt-get install chromium-browser

GPIO

如果要在 Jetson 中使用硬件 PWM，则需要修改 Pinmux 表来多路复用。Jetpack 提供了一个名为 jetson-io 的工具，它允许创建和更新可以使用 PWM 的 dtb。

1	sudo /opt/nvidia/jetson-io/jetson-io.py

选择 Configure Jetson 40pin Header > Configure header pins manually ， pwm7(32)选择并 Back，Save pin changes ，Save and reboot to reconfigure pins，按下任意键后重启，即可完成设置。

libgpiod

在使用第三方载板时，jetson-io工具无法确定载板型号。需要手动配置引脚复用。

nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ sudo cat /sys/kernel/debug/gpio | grep PG.06
 gpio-389 (PG.06               |usbhub_power_en     ) out lo 
nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ ^C
nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ sudo cat /sys/kernel/debug/gpio | grep PH.00
 gpio-391 (PH.00               |m2_KeyB_power_en    ) out lo 
nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ 
nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ sudo cat /sys/kernel/debug/gpio | grep PN.01
 gpio-433 (PN.01               )
nvidia@tegra-ubuntu:/sys/class/pwm/pwmchip4$ sudo cat /sys/kernel/debug/gpio | grep PCC.00
 gpio-328 (PCC.00              |user-led            ) out lo

但是载板并没有引出PWM引脚，使用GPIO模拟。

sudo apt-get install libgpiod-dev

sudo gpioinfo

设置 GPIO 高低：sudo gpioset --mode=wait gpiochip0 106=1

sudo gpioset --mode=wait gpiochip0 106=0

GPIO占用

Orin NX Super 设备树路径: /bus@0/i2c@c250000/gpio@24

# 查看当前状态
fdtget /boot/dtb/kernel_tegra234-p3768-0000+p3767-0000-nv-super.dtb \
    /bus@0/i2c@c250000/gpio@24/j16-30 status
# 输出: okay

# 备份 DTB
sudo cp /boot/dtb/kernel_tegra234-p3768-0000+p3767-0000-nv-super.dtb \
       /boot/dtb/kernel_tegra234-p3768-0000+p3767-0000-nv-super.dtb.bak

# 禁用 j16-30 hog (gpiochip2 line 7)
sudo fdtput -t s /boot/dtb/kernel_tegra234-p3768-0000+p3767-0000-nv-super.dtb \
    /bus@0/i2c@c250000/gpio@24/j16-30 status disabled

# 验证修改
fdtget /boot/dtb/kernel_tegra234-p3768-0000+p3767-0000-nv-super.dtb \
    /bus@0/i2c@c250000/gpio@24/j16-30 status
# 输出: disabled

# 重启生效
sudo reboot

重启后验证:

sudo gpioinfo gpiochip2
# line 7 应显示 "unused" 而非 "[used]"

sudo gpioget gpiochip2 7
# 应输出 0 (成功) 而不是 "Device or resource busy"

恢复方法: sudo cp /boot/dtb/...nv-super.dtb.bak /boot/dtb/...nv-super.dtb && sudo reboot

opencv

https://jishuzhan.net/article/2013776823067918337

需要手动编译OpenCV 以支持 CUDA 加速

一键安装脚本，修改version (OpenCV 版本)，ARCH_BIN (CUDA 算力架构)，PYTHON_VERSION_NUM (Python 版本)

Jetson 设备型号	架构代号	ARCH_BIN 修改值	备注
Jetson AGX Orin	Ampere	“8.7”	脚本默认值
Jetson Orin NX	Ampere	“8.7”	与 AGX Orin 相同
Jetson Orin Nano	Ampere	“8.7”	与 AGX Orin 相同
Jetson AGX Xavier	Volta	“7.2”
Jetson Xavier NX	Volta	“7.2”
Jetson TX2	Pascal	“6.2”
Jetson Nano (B01)	Maxwell	“5.3”	老款 Nano 请填这个

#!/bin/bash
#
# Copyright (c) 2024.
# Modified for Jetson Orin NX (CUDA Arch 8.7)
# Based on instructions for OpenCV 4.10.0
#

# ================= 配置区域 (Config Area) =================

# 1. OpenCV 版本
version="4.10.0"

# 2. CUDA 算力架构 (重要!)
# Orin 系列 (AGX Orin, Orin NX, Orin Nano) -> 8.7
# Xavier 系列 -> 7.2
# Nano/TX1 -> 5.3
ARCH_BIN="8.7"

# 3. Python 版本 (根据你的系统修改)
# 运行 'python3 --version' 查看
# Jetpack 5 (Ubuntu 20.04) 通常是 3.8
# Jetpack 6 (Ubuntu 22.04) 通常是 3.10
PYTHON_VERSION_NUM="3.10" 

# 工作目录
folder="workspace"

# =========================================================

set -e

# ---------------------------------------------------------
# 0. 清理旧版本交互
# ---------------------------------------------------------
for (( ; ; ))
do
    echo "Do you want to remove the default OpenCV (yes/no)?"
    read rm_old

    if [ "$rm_old" = "yes" ]; then
        echo "** Remove other OpenCV first"
        sudo apt -y purge *libopencv*
        break
    elif [ "$rm_old" = "no" ]; then
        break
    fi
done

echo "------------------------------------"
echo "** Install requirement (1/4)"
echo "------------------------------------"
sudo apt-get update
# 安装基础编译工具
sudo apt-get install -y build-essential cmake git pkg-config unzip curl

# 图像/视频编解码库
sudo apt-get install -y libavcodec-dev libavformat-dev libswscale-dev
sudo apt-get install -y libgstreamer1.0-dev libgstreamer-plugins-base1.0-dev
sudo apt-get install -y libv4l-dev v4l-utils qv4l2

# 图片格式库
sudo apt-get install -y libjpeg-dev libpng-dev libtiff-dev

# TBB 并行库 (兼容处理: Ubuntu 22.04 使用 libtbb12, 旧版使用 libtbb2)
sudo apt-get install -y libtbb-dev
if apt-cache search --names-only '^libtbb2$' | grep -q libtbb2; then
    sudo apt-get install -y libtbb2
elif apt-cache search --names-only '^libtbb12$' | grep -q libtbb12; then
    sudo apt-get install -y libtbb12
fi

# GUI 支持
sudo apt-get install -y libgtk2.0-dev 

echo "------------------------------------"
echo "** Download opencv ${version} (2/4)"
echo "------------------------------------"
mkdir -p $folder
cd ${folder}

# 下载 OpenCV 源码 (增加防重复下载判断)
if [ ! -f "opencv-${version}.zip" ]; then
    echo "Downloading OpenCV source..."
    curl -L https://github.com/opencv/opencv/archive/${version}.zip -o opencv-${version}.zip
else
    echo "opencv-${version}.zip already exists."
fi

# 下载 Contrib 源码
if [ ! -f "opencv_contrib-${version}.zip" ]; then
    echo "Downloading OpenCV Contrib source..."
    curl -L https://github.com/opencv/opencv_contrib/archive/${version}.zip -o opencv_contrib-${version}.zip
else
    echo "opencv_contrib-${version}.zip already exists."
fi

# 解压
echo "Unzipping..."
unzip -o opencv-${version}.zip > /dev/null
unzip -o opencv_contrib-${version}.zip > /dev/null

# 清理压缩包(可选，这里保留以免重试时需要重新下载，如果空间不足可取消注释)
# rm opencv-${version}.zip opencv_contrib-${version}.zip

cd opencv-${version}/

echo "------------------------------------"
echo "** Build opencv ${version} (3/4)"
echo "------------------------------------"
mkdir -p release
cd release/

# CMake 配置
# 注意：Orin NX 使用 8.7 架构
cmake -D WITH_CUDA=ON \
      -D WITH_CUDNN=ON \
      -D CUDA_ARCH_BIN="${ARCH_BIN}" \
      -D CUDA_ARCH_PTX="" \
      -D OPENCV_GENERATE_PKGCONFIG=ON \
      -D OPENCV_EXTRA_MODULES_PATH=../../opencv_contrib-${version}/modules \
      -D WITH_GSTREAMER=ON \
      -D WITH_LIBV4L=ON \
      -D BUILD_opencv_python3=ON \
      -D BUILD_opencv_gapi=OFF \
      -D BUILD_TESTS=OFF \
      -D BUILD_PERF_TESTS=OFF \
      -D BUILD_EXAMPLES=OFF \
      -D CMAKE_BUILD_TYPE=RELEASE \
      -D CMAKE_INSTALL_PREFIX=/usr/local ..

echo "Compiling... This may take a while."
make -j$(nproc)

echo "------------------------------------"
echo "** Install opencv ${version} (4/4)"
echo "------------------------------------"
sudo make install

# 配置环境变量到 .bashrc
# 判断是否已经存在，避免重复写入
if ! grep -q "export LD_LIBRARY_PATH=/usr/local/lib" ~/.bashrc; then
    echo 'export LD_LIBRARY_PATH=/usr/local/lib:$LD_LIBRARY_PATH' >> ~/.bashrc
fi

# 根据 Python 版本路径配置 PYTHONPATH
SITE_PACKAGES_PATH="/usr/local/lib/python${PYTHON_VERSION_NUM}/site-packages"

if ! grep -q "export PYTHONPATH=${SITE_PACKAGES_PATH}" ~/.bashrc; then
    echo "export PYTHONPATH=${SITE_PACKAGES_PATH}/:\$PYTHONPATH" >> ~/.bashrc
fi

# 提示用户手动 source
echo "------------------------------------"
echo "** Install opencv ${version} successfully"
echo "** IMPORTANT: Please run the following command to apply changes:"
echo "   source ~/.bashrc"
echo "** Bye :)"

MVS

到下载页面下载：

海康机器人-机器视觉-下载中心

机器视觉工业相机SDK Runtime组件包（Linux）V4.7.0

MvCamCtrlSDK_Runtime-4.7.0_aarch64_20251113.deb

TensorRT

添加工具软链接

1	sudo ln -s /usr/src/tensorrt/bin/trtexec /usr/local/bin/trtexec

cuda-toolkit

安装

sudo apt-get install cuda-toolkit

在~/.bashrc文件末尾添加

1
2
3

export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-12.6/lib64
export PATH=$PATH:/usr/local/cuda-12.6/bin
export CUDA_HOME=$CUDA_HOME:/usr/local/cuda-12.6

使用检索

trtexec使用

pt导出onnx(动态纬度)

1	yolo export model=best.pt format=onnx dynamic=True opset=12

转换模型

trtexec \
--onnx=best.onnx \
--saveEngine=yolo11n.engine \
--fp16 \
--minShapes=images:1x3x640x640 \
--optShapes=images:1x3x640x640 \
--maxShapes=images:1x3x640x640 \
--memPoolSize=workspace:4096 \
--verbose

导出batch2模型

trtexec \
--onnx=best.onnx \
--saveEngine=yolo11n_batch2.engine \
--fp16 \
--minShapes=images:2x3x640x640 \
--optShapes=images:2x3x640x640 \
--maxShapes=images:2x3x640x640 \
--verbose

MVS使用

开始

DLA推理

纯 DLA 推理 yolo26 模型时，两个 attention 模块（model.10 和 model.22）在 DLA 上耗时极高，
nsys profiling 显示：

1
2
3

ForeignNode[2] (model.10 attention body): 4.56ms  28.0%  ← 瓶颈
ForeignNode[4] (model.22 attention body): 4.59ms  28.2%  ← 瓶颈
两者合计: 9.15ms = 56% of total 16.26ms

model.0-model.9   : Backbone (Conv + C3k2 blocks)      [DLA 兼容]
model.10           : C2PSA block (含 PSA attention)      [DLA 兼容但慢]
model.11-model.21  : Neck (SPPF + Upsample + C3k2)     [DLA 兼容]
model.22           : C2PSA block (含 PSA attention)      [DLA 兼容但慢]
model.23           : Detection Head (Conv + Concat + decode) [DLA 兼容]

模型结构

{
  "Layers": [
    "Reformatting CopyNode for Input Tensor 0 to /model.0/conv/Conv + PWN(PWN(/model.0/act/Sigmoid), PWN(/model.0/act/Mul))",
    "/model.0/conv/Conv + PWN(PWN(/model.0/act/Sigmoid), PWN(/model.0/act/Mul))",
    "/model.1/conv/Conv + PWN(PWN(/model.1/act/Sigmoid), PWN(/model.1/act/Mul))",
    "/model.2/cv1/conv/Conv + PWN(PWN(/model.2/cv1/act/Sigmoid), PWN(/model.2/cv1/act/Mul))",
    "/model.2/Split_1",
    "/model.2/m.0/cv1/conv/Conv + PWN(PWN(/model.2/m.0/cv1/act/Sigmoid), PWN(/model.2/m.0/cv1/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.2/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.2/m.0/cv2/act/Sigmoid), PWN(/model.2/m.0/cv2/act/Mul)), PWN(/model.2/m.0/Add))",
    "Reformatting CopyNode for Input Tensor 1 to /model.2/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.2/m.0/cv2/act/Sigmoid), PWN(/model.2/m.0/cv2/act/Mul)), PWN(/model.2/m.0/Add))",
    "/model.2/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.2/m.0/cv2/act/Sigmoid), PWN(/model.2/m.0/cv2/act/Mul)), PWN(/model.2/m.0/Add))",
    "/model.2/Split_output_0 copy",
    "/model.2/Split_output_1 copy",
    "/model.2/m.0/Add_output_0 copy",
    "/model.2/cv2/conv/Conv + PWN(PWN(/model.2/cv2/act/Sigmoid), PWN(/model.2/cv2/act/Mul))",
    "/model.3/conv/Conv + PWN(PWN(/model.3/act/Sigmoid), PWN(/model.3/act/Mul))",
    "/model.4/cv1/conv/Conv + PWN(PWN(/model.4/cv1/act/Sigmoid), PWN(/model.4/cv1/act/Mul))",
    "/model.4/Split_4",
    "/model.4/m.0/cv1/conv/Conv + PWN(PWN(/model.4/m.0/cv1/act/Sigmoid), PWN(/model.4/m.0/cv1/act/Mul))",
    "/model.4/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.4/m.0/cv2/act/Sigmoid), PWN(/model.4/m.0/cv2/act/Mul)), PWN(/model.4/m.0/Add))",
    "/model.4/Split_output_0 copy",
    "/model.4/Split_output_1 copy",
    "/model.4/m.0/Add_output_0 copy",
    "/model.4/cv2/conv/Conv + PWN(PWN(/model.4/cv2/act/Sigmoid), PWN(/model.4/cv2/act/Mul))",
    "/model.5/conv/Conv + PWN(PWN(/model.5/act/Sigmoid), PWN(/model.5/act/Mul))",
    "/model.6/cv1/conv/Conv + PWN(PWN(/model.6/cv1/act/Sigmoid), PWN(/model.6/cv1/act/Mul))",
    "/model.6/m.0/cv1/conv/Conv + PWN(PWN(/model.6/m.0/cv1/act/Sigmoid), PWN(/model.6/m.0/cv1/act/Mul))",
    "/model.6/m.0/m/m.0/cv1/conv/Conv + PWN(PWN(/model.6/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.6/m.0/m/m.0/cv1/act/Mul))",
    "/model.6/m.0/m/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.6/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.6/m.0/m/m.0/cv2/act/Mul)), PWN(/model.6/m.0/m/m.0/Add))",
    "/model.6/m.0/m/m.1/cv1/conv/Conv + PWN(PWN(/model.6/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.6/m.0/m/m.1/cv1/act/Mul))",
    "/model.6/m.0/m/m.1/cv2/conv/Conv + PWN(PWN(PWN(/model.6/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.6/m.0/m/m.1/cv2/act/Mul)), PWN(/model.6/m.0/m/m.1/Add))",
    "/model.6/m.0/cv2/conv/Conv + PWN(PWN(/model.6/m.0/cv2/act/Sigmoid), PWN(/model.6/m.0/cv2/act/Mul))",
    "/model.6/m.0/m/m.1/Add_output_0 copy",
    "/model.6/m.0/cv3/conv/Conv + PWN(PWN(/model.6/m.0/cv3/act/Sigmoid), PWN(/model.6/m.0/cv3/act/Mul))",
    "/model.6/Split_output_0 copy",
    "/model.6/Split_output_1 copy",
    "/model.6/cv2/conv/Conv + PWN(PWN(/model.6/cv2/act/Sigmoid), PWN(/model.6/cv2/act/Mul))",
    "/model.7/conv/Conv + PWN(PWN(/model.7/act/Sigmoid), PWN(/model.7/act/Mul))",
    "/model.8/cv1/conv/Conv + PWN(PWN(/model.8/cv1/act/Sigmoid), PWN(/model.8/cv1/act/Mul))",
    "/model.8/m.0/cv1/conv/Conv + PWN(PWN(/model.8/m.0/cv1/act/Sigmoid), PWN(/model.8/m.0/cv1/act/Mul))",
    "/model.8/m.0/m/m.0/cv1/conv/Conv + PWN(PWN(/model.8/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.8/m.0/m/m.0/cv1/act/Mul))",
    "/model.8/m.0/m/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.8/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.8/m.0/m/m.0/cv2/act/Mul)), PWN(/model.8/m.0/m/m.0/Add))",
    "/model.8/m.0/m/m.1/cv1/conv/Conv + PWN(PWN(/model.8/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.8/m.0/m/m.1/cv1/act/Mul))",
    "/model.8/m.0/m/m.1/cv2/conv/Conv + PWN(PWN(PWN(/model.8/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.8/m.0/m/m.1/cv2/act/Mul)), PWN(/model.8/m.0/m/m.1/Add))",
    "/model.8/m.0/cv2/conv/Conv + PWN(PWN(/model.8/m.0/cv2/act/Sigmoid), PWN(/model.8/m.0/cv2/act/Mul))",
    "/model.8/m.0/m/m.1/Add_output_0 copy",
    "/model.8/m.0/cv3/conv/Conv + PWN(PWN(/model.8/m.0/cv3/act/Sigmoid), PWN(/model.8/m.0/cv3/act/Mul))",
    "/model.8/Split_output_0 copy",
    "/model.8/Split_output_1 copy",
    "/model.8/cv2/conv/Conv + PWN(PWN(/model.8/cv2/act/Sigmoid), PWN(/model.8/cv2/act/Mul))",
    "/model.9/cv1/conv/Conv",
    "/model.9/m/MaxPool",
    "/model.9/m_1/MaxPool",
    "/model.9/m_2/MaxPool",
    "/model.9/cv1/conv/Conv_output_0 copy",
    "/model.9/m/MaxPool_output_0 copy",
    "/model.9/m_1/MaxPool_output_0 copy",
    "/model.9/cv2/conv/Conv + PWN(PWN(/model.9/cv2/act/Sigmoid), PWN(/model.9/cv2/act/Mul))",
    "/model.10/cv1/conv/Conv + PWN(PWN(/model.10/cv1/act/Sigmoid), PWN(/model.10/cv1/act/Mul))",
    "/model.10/Split_13",
    "/model.10/m/m.0/attn/qkv/conv/Conv",
    "/model.10/m/m.0/attn/Reshape",
    "/model.10/m/m.0/attn/Split",
    "/model.10/m/m.0/attn/Split_16",
    "/model.10/m/m.0/attn/MatMul",
    "/model.10/m/m.0/attn/Softmax",
    "/model.10/m/m.0/attn/Split_18",
    "/model.10/m/m.0/attn/Reshape_2",
    "/model.10/m/m.0/attn/MatMul_1",
    "/model.10/m/m.0/attn/Reshape_1",
    "/model.10/m/m.0/attn/pe/conv/Conv + /model.10/m/m.0/attn/Add",
    "Reformatting CopyNode for Input Tensor 0 to /model.10/m/m.0/attn/proj/conv/Conv + /model.10/m/m.0/Add",
    "/model.10/m/m.0/attn/proj/conv/Conv + /model.10/m/m.0/Add",
    "/model.10/m/m.0/ffn/ffn.0/conv/Conv + PWN(PWN(/model.10/m/m.0/ffn/ffn.0/act/Sigmoid), PWN(/model.10/m/m.0/ffn/ffn.0/act/Mul))",
    "/model.10/m/m.0/ffn/ffn.1/conv/Conv + /model.10/m/m.0/Add_1",
    "/model.10/Split_output_0 copy",
    "/model.10/m/m.0/Add_1_output_0 copy",
    "/model.10/cv2/conv/Conv + PWN(PWN(/model.10/cv2/act/Sigmoid), PWN(/model.10/cv2/act/Mul))",
    "/model.11/Resize",
    "/model.11/Resize_output_0 copy",
    "/model.13/cv1/conv/Conv + PWN(PWN(/model.13/cv1/act/Sigmoid), PWN(/model.13/cv1/act/Mul))",
    "/model.13/m.0/cv1/conv/Conv + PWN(PWN(/model.13/m.0/cv1/act/Sigmoid), PWN(/model.13/m.0/cv1/act/Mul))",
    "/model.13/m.0/m/m.0/cv1/conv/Conv + PWN(PWN(/model.13/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.13/m.0/m/m.0/cv1/act/Mul))",
    "/model.13/m.0/m/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.13/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.13/m.0/m/m.0/cv2/act/Mul)), PWN(/model.13/m.0/m/m.0/Add))",
    "/model.13/m.0/m/m.1/cv1/conv/Conv + PWN(PWN(/model.13/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.13/m.0/m/m.1/cv1/act/Mul))",
    "/model.13/m.0/m/m.1/cv2/conv/Conv + PWN(PWN(PWN(/model.13/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.13/m.0/m/m.1/cv2/act/Mul)), PWN(/model.13/m.0/m/m.1/Add))",
    "/model.13/m.0/cv2/conv/Conv + PWN(PWN(/model.13/m.0/cv2/act/Sigmoid), PWN(/model.13/m.0/cv2/act/Mul))",
    "/model.13/m.0/m/m.1/Add_output_0 copy",
    "/model.13/m.0/cv3/conv/Conv + PWN(PWN(/model.13/m.0/cv3/act/Sigmoid), PWN(/model.13/m.0/cv3/act/Mul))",
    "/model.13/Split_output_0 copy",
    "/model.13/Split_output_1 copy",
    "/model.13/cv2/conv/Conv + PWN(PWN(/model.13/cv2/act/Sigmoid), PWN(/model.13/cv2/act/Mul))",
    "/model.14/Resize",
    "/model.14/Resize_output_0 copy",
    "/model.16/cv1/conv/Conv + PWN(PWN(/model.16/cv1/act/Sigmoid), PWN(/model.16/cv1/act/Mul))",
    "/model.16/m.0/cv1/conv/Conv + PWN(PWN(/model.16/m.0/cv1/act/Sigmoid), PWN(/model.16/m.0/cv1/act/Mul))",
    "Reformatting CopyNode for Output Tensor 0 to /model.16/m.0/cv1/conv/Conv + PWN(PWN(/model.16/m.0/cv1/act/Sigmoid), PWN(/model.16/m.0/cv1/act/Mul))",
    "/model.16/m.0/m/m.0/cv1/conv/Conv",
    "Reformatting CopyNode for Input Tensor 0 to PWN(PWN(/model.16/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.16/m.0/m/m.0/cv1/act/Mul))",
    "PWN(PWN(/model.16/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.16/m.0/m/m.0/cv1/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.16/m.0/m/m.0/cv2/conv/Conv",
    "/model.16/m.0/m/m.0/cv2/conv/Conv",
    "Reformatting CopyNode for Input Tensor 0 to PWN(PWN(PWN(/model.16/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.0/cv2/act/Mul)), PWN(/model.16/m.0/m/m.0/Add))",
    "Reformatting CopyNode for Input Tensor 1 to PWN(PWN(PWN(/model.16/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.0/cv2/act/Mul)), PWN(/model.16/m.0/m/m.0/Add))",
    "PWN(PWN(PWN(/model.16/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.0/cv2/act/Mul)), PWN(/model.16/m.0/m/m.0/Add))",
    "Reformatting CopyNode for Input Tensor 0 to /model.16/m.0/m/m.1/cv1/conv/Conv",
    "/model.16/m.0/m/m.1/cv1/conv/Conv",
    "Reformatting CopyNode for Input Tensor 0 to PWN(PWN(/model.16/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.16/m.0/m/m.1/cv1/act/Mul))",
    "PWN(PWN(/model.16/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.16/m.0/m/m.1/cv1/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.16/m.0/m/m.1/cv2/conv/Conv",
    "/model.16/m.0/m/m.1/cv2/conv/Conv",
    "Reformatting CopyNode for Input Tensor 0 to PWN(PWN(PWN(/model.16/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.1/cv2/act/Mul)), PWN(/model.16/m.0/m/m.1/Add))",
    "PWN(PWN(PWN(/model.16/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.1/cv2/act/Mul)), PWN(/model.16/m.0/m/m.1/Add))",
    "Reformatting CopyNode for Output Tensor 0 to PWN(PWN(PWN(/model.16/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.16/m.0/m/m.1/cv2/act/Mul)), PWN(/model.16/m.0/m/m.1/Add))",
    "Reformatting CopyNode for Input Tensor 0 to /model.16/m.0/cv2/conv/Conv + PWN(PWN(/model.16/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/cv2/act/Mul))",
    "/model.16/m.0/cv2/conv/Conv + PWN(PWN(/model.16/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/cv2/act/Mul))",
    "Reformatting CopyNode for Output Tensor 0 to /model.16/m.0/cv2/conv/Conv + PWN(PWN(/model.16/m.0/cv2/act/Sigmoid), PWN(/model.16/m.0/cv2/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.16/m.0/cv3/conv/Conv + PWN(PWN(/model.16/m.0/cv3/act/Sigmoid), PWN(/model.16/m.0/cv3/act/Mul))",
    "/model.16/m.0/cv3/conv/Conv + PWN(PWN(/model.16/m.0/cv3/act/Sigmoid), PWN(/model.16/m.0/cv3/act/Mul))",
    "/model.16/Split_output_0 copy",
    "/model.16/Split_output_1 copy",
    "/model.16/cv2/conv/Conv + PWN(PWN(/model.16/cv2/act/Sigmoid), PWN(/model.16/cv2/act/Mul))",
    "/model.17/conv/Conv + PWN(PWN(/model.17/act/Sigmoid), PWN(/model.17/act/Mul))",
    "/model.13/cv2/act/Mul_output_0 copy",
    "/model.19/cv1/conv/Conv + PWN(PWN(/model.19/cv1/act/Sigmoid), PWN(/model.19/cv1/act/Mul))",
    "/model.19/m.0/cv1/conv/Conv + PWN(PWN(/model.19/m.0/cv1/act/Sigmoid), PWN(/model.19/m.0/cv1/act/Mul))",
    "/model.19/m.0/m/m.0/cv1/conv/Conv + PWN(PWN(/model.19/m.0/m/m.0/cv1/act/Sigmoid), PWN(/model.19/m.0/m/m.0/cv1/act/Mul))",
    "/model.19/m.0/m/m.0/cv2/conv/Conv + PWN(PWN(PWN(/model.19/m.0/m/m.0/cv2/act/Sigmoid), PWN(/model.19/m.0/m/m.0/cv2/act/Mul)), PWN(/model.19/m.0/m/m.0/Add))",
    "/model.19/m.0/m/m.1/cv1/conv/Conv + PWN(PWN(/model.19/m.0/m/m.1/cv1/act/Sigmoid), PWN(/model.19/m.0/m/m.1/cv1/act/Mul))",
    "/model.19/m.0/m/m.1/cv2/conv/Conv + PWN(PWN(PWN(/model.19/m.0/m/m.1/cv2/act/Sigmoid), PWN(/model.19/m.0/m/m.1/cv2/act/Mul)), PWN(/model.19/m.0/m/m.1/Add))",
    "/model.19/m.0/cv2/conv/Conv + PWN(PWN(/model.19/m.0/cv2/act/Sigmoid), PWN(/model.19/m.0/cv2/act/Mul))",
    "/model.19/m.0/m/m.1/Add_output_0 copy",
    "/model.19/m.0/cv3/conv/Conv + PWN(PWN(/model.19/m.0/cv3/act/Sigmoid), PWN(/model.19/m.0/cv3/act/Mul))",
    "/model.19/Split_output_0 copy",
    "/model.19/Split_output_1 copy",
    "/model.19/cv2/conv/Conv + PWN(PWN(/model.19/cv2/act/Sigmoid), PWN(/model.19/cv2/act/Mul))",
    "/model.20/conv/Conv + PWN(PWN(/model.20/act/Sigmoid), PWN(/model.20/act/Mul))",
    "/model.10/cv2/act/Mul_output_0 copy",
    "/model.22/cv1/conv/Conv + PWN(PWN(/model.22/cv1/act/Sigmoid), PWN(/model.22/cv1/act/Mul))",
    "/model.22/Split_34",
    "/model.22/m.0/m.0.0/cv1/conv/Conv + PWN(PWN(/model.22/m.0/m.0.0/cv1/act/Sigmoid), PWN(/model.22/m.0/m.0.0/cv1/act/Mul))",
    "/model.22/m.0/m.0.0/cv2/conv/Conv + PWN(PWN(PWN(/model.22/m.0/m.0.0/cv2/act/Sigmoid), PWN(/model.22/m.0/m.0.0/cv2/act/Mul)), PWN(/model.22/m.0/m.0.0/Add))",
    "/model.22/m.0/m.0.1/attn/qkv/conv/Conv",
    "/model.22/m.0/m.0.1/attn/Reshape",
    "/model.22/m.0/m.0.1/attn/Split",
    "/model.22/m.0/m.0.1/attn/Split_38",
    "/model.22/m.0/m.0.1/attn/MatMul",
    "/model.22/m.0/m.0.1/attn/Softmax",
    "/model.22/m.0/m.0.1/attn/Split_40",
    "/model.22/m.0/m.0.1/attn/Reshape_2",
    "/model.22/m.0/m.0.1/attn/MatMul_1",
    "/model.22/m.0/m.0.1/attn/Reshape_1",
    "/model.22/m.0/m.0.1/attn/pe/conv/Conv + /model.22/m.0/m.0.1/attn/Add",
    "Reformatting CopyNode for Input Tensor 0 to /model.22/m.0/m.0.1/attn/proj/conv/Conv + /model.22/m.0/m.0.1/Add",
    "/model.22/m.0/m.0.1/attn/proj/conv/Conv + /model.22/m.0/m.0.1/Add",
    "/model.22/m.0/m.0.1/ffn/ffn.0/conv/Conv + PWN(PWN(/model.22/m.0/m.0.1/ffn/ffn.0/act/Sigmoid), PWN(/model.22/m.0/m.0.1/ffn/ffn.0/act/Mul))",
    "/model.22/m.0/m.0.1/ffn/ffn.1/conv/Conv + /model.22/m.0/m.0.1/Add_1",
    "/model.22/Split_output_0 copy",
    "/model.22/Split_output_1 copy",
    "/model.22/m.0/m.0.1/Add_1_output_0 copy",
    "/model.22/cv2/conv/Conv + PWN(PWN(/model.22/cv2/act/Sigmoid), PWN(/model.22/cv2/act/Mul))",
    "/model.23/cv2.2/cv2.2.0/conv/Conv + PWN(PWN(/model.23/cv2.2/cv2.2.0/act/Sigmoid), PWN(/model.23/cv2.2/cv2.2.0/act/Mul))",
    "/model.23/cv2.2/cv2.2.1/conv/Conv",
    "PWN(PWN(/model.23/cv2.2/cv2.2.1/act/Sigmoid), PWN(/model.23/cv2.2/cv2.2.1/act/Mul))",
    "/model.23/cv2.2/cv2.2.2/Conv",
    "/model.23/cv3.2/cv3.2.0/cv3.2.0.0/conv/Conv + PWN(PWN(/model.23/cv3.2/cv3.2.0/cv3.2.0.0/act/Sigmoid), PWN(/model.23/cv3.2/cv3.2.0/cv3.2.0.0/act/Mul))",
    "/model.23/cv3.2/cv3.2.0/cv3.2.0.1/conv/Conv + PWN(PWN(/model.23/cv3.2/cv3.2.0/cv3.2.0.1/act/Sigmoid), PWN(/model.23/cv3.2/cv3.2.0/cv3.2.0.1/act/Mul))",
    "/model.23/cv3.2/cv3.2.1/cv3.2.1.0/conv/Conv + PWN(PWN(/model.23/cv3.2/cv3.2.1/cv3.2.1.0/act/Sigmoid), PWN(/model.23/cv3.2/cv3.2.1/cv3.2.1.0/act/Mul))",
    "/model.23/cv3.2/cv3.2.1/cv3.2.1.1/conv/Conv + PWN(PWN(/model.23/cv3.2/cv3.2.1/cv3.2.1.1/act/Sigmoid), PWN(/model.23/cv3.2/cv3.2.1/cv3.2.1.1/act/Mul))",
    "/model.23/cv3.2/cv3.2.2/Conv",
    "/model.23/Reshape_2",
    "/model.23/Reshape_2_copy_output",
    "/model.23/cv2.1/cv2.1.0/conv/Conv + PWN(PWN(/model.23/cv2.1/cv2.1.0/act/Sigmoid), PWN(/model.23/cv2.1/cv2.1.0/act/Mul))",
    "/model.23/cv2.1/cv2.1.1/conv/Conv",
    "PWN(PWN(/model.23/cv2.1/cv2.1.1/act/Sigmoid), PWN(/model.23/cv2.1/cv2.1.1/act/Mul))",
    "/model.23/cv2.1/cv2.1.2/Conv",
    "/model.23/cv3.1/cv3.1.0/cv3.1.0.0/conv/Conv + PWN(PWN(/model.23/cv3.1/cv3.1.0/cv3.1.0.0/act/Sigmoid), PWN(/model.23/cv3.1/cv3.1.0/cv3.1.0.0/act/Mul))",
    "/model.23/cv3.1/cv3.1.0/cv3.1.0.1/conv/Conv + PWN(PWN(/model.23/cv3.1/cv3.1.0/cv3.1.0.1/act/Sigmoid), PWN(/model.23/cv3.1/cv3.1.0/cv3.1.0.1/act/Mul))",
    "/model.23/cv3.1/cv3.1.1/cv3.1.1.0/conv/Conv + PWN(PWN(/model.23/cv3.1/cv3.1.1/cv3.1.1.0/act/Sigmoid), PWN(/model.23/cv3.1/cv3.1.1/cv3.1.1.0/act/Mul))",
    "/model.23/cv3.1/cv3.1.1/cv3.1.1.1/conv/Conv + PWN(PWN(/model.23/cv3.1/cv3.1.1/cv3.1.1.1/act/Sigmoid), PWN(/model.23/cv3.1/cv3.1.1/cv3.1.1.1/act/Mul))",
    "/model.23/cv3.1/cv3.1.2/Conv",
    "/model.23/Reshape_1",
    "/model.23/Reshape_1_copy_output",
    "/model.23/cv2.0/cv2.0.0/conv/Conv + PWN(PWN(/model.23/cv2.0/cv2.0.0/act/Sigmoid), PWN(/model.23/cv2.0/cv2.0.0/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.23/cv2.0/cv2.0.1/conv/Conv",
    "/model.23/cv2.0/cv2.0.1/conv/Conv",
    "Reformatting CopyNode for Input Tensor 0 to PWN(PWN(/model.23/cv2.0/cv2.0.1/act/Sigmoid), PWN(/model.23/cv2.0/cv2.0.1/act/Mul))",
    "PWN(PWN(/model.23/cv2.0/cv2.0.1/act/Sigmoid), PWN(/model.23/cv2.0/cv2.0.1/act/Mul))",
    "Reformatting CopyNode for Input Tensor 0 to /model.23/cv2.0/cv2.0.2/Conv",
    "/model.23/cv2.0/cv2.0.2/Conv",
    "Reformatting CopyNode for Output Tensor 0 to /model.23/cv2.0/cv2.0.2/Conv",
    "/model.23/cv3.0/cv3.0.0/cv3.0.0.0/conv/Conv + PWN(PWN(/model.23/cv3.0/cv3.0.0/cv3.0.0.0/act/Sigmoid), PWN(/model.23/cv3.0/cv3.0.0/cv3.0.0.0/act/Mul))",
    "/model.23/cv3.0/cv3.0.0/cv3.0.0.1/conv/Conv + PWN(PWN(/model.23/cv3.0/cv3.0.0/cv3.0.0.1/act/Sigmoid), PWN(/model.23/cv3.0/cv3.0.0/cv3.0.0.1/act/Mul))",
    "/model.23/cv3.0/cv3.0.1/cv3.0.1.0/conv/Conv + PWN(PWN(/model.23/cv3.0/cv3.0.1/cv3.0.1.0/act/Sigmoid), PWN(/model.23/cv3.0/cv3.0.1/cv3.0.1.0/act/Mul))",
    "/model.23/cv3.0/cv3.0.1/cv3.0.1.1/conv/Conv + PWN(PWN(/model.23/cv3.0/cv3.0.1/cv3.0.1.1/act/Sigmoid), PWN(/model.23/cv3.0/cv3.0.1/cv3.0.1.1/act/Mul))",
    "/model.23/cv3.0/cv3.0.2/Conv",
    "/model.23/Reshape",
    "/model.23/Reshape_copy_output",
    "PWN(/model.23/Sigmoid)",
    "/model.23/Constant_12_output_0 + ONNXTRT_Broadcast_117",
    "/model.23/Constant_10_output_0",
    "PWN(/model.23/Add_1)",
    "/model.23/Constant_9_output_0",
    "PWN(/model.23/Sub)",
    "PWN(/model.23/Sub_1)",
    "PWN(PWN(/model.23/Add_2), PWN(/model.23/Constant_11_output_0 + ONNXTRT_Broadcast_115, PWN(/model.23/Div_1)))",
    "/model.23/Div_1_output_0 copy",
    "PWN(/model.23/Mul_2)",
    "/model.23/Mul_2_output_0 copy"
  ],
  "Bindings": [
    "images",
    "output0"
  ]
}

Q&A

Errors were encountered while processing: nvidia-l4t-bootloader报错

Jetson升级踩坑实录：nvidia-l4t-bootloader报错终极解决方案（附完整命令）-CSDN博客

Jetson Orin NX 性能检测工具指南

Jetson Orin NX 上可用于 TensorRT / CUDA / DLA 性能分析的核心工具：

工具	用途	安装状态
`nsys` (Nsight Systems)	GPU/DLA/CPU timeline profiling	自带 (2024.5.4)
`trtexec`	TensorRT engine benchmark & layer profiling	自带 (TRT 10.3)
`tegrastats`	实时 GPU/DLA/CPU/内存/温度监控	自带
`jtop`	交互式系统资源监控	pip install jetson-stats
`nvpmodel`	功耗/性能模式切换	自带
`jetson_clocks`	锁定最高频率	自带

注意：nvvp (Visual Profiler) 在 JetPack 6.x 已废弃，由 nsys 替代。

1. nsys (Nsight Systems)

1.1 基本用法

# 版本确认
nsys --version
# NVIDIA Nsight Systems version 2024.5.4.34-...

# 基础 profiling (应用级)
nsys profile -o my_report ./my_application

# 指定采样选项
nsys profile \
    -t cuda,nvtx,osrt \        # 追踪 CUDA, NVTX markers, OS Runtime
    --duration=10 \             # 采集 10 秒
    --stats=true \              # 生成统计摘要
    -o profile_output \
    ./my_application

1.2 TensorRT + DLA Profiling

# 对 trtexec DLA engine 进行 profiling
nsys profile \
    --stats=true \
    -o dla_profile \
    /usr/src/tensorrt/bin/trtexec \
        --loadEngine=model/yolo26_dla0_int8_640.engine \
        --iterations=200 \
        --warmUp=2000 \
        --dumpProfile

1.3 关键输出解读

# nsys stats 输出示例:
CUDA API Statistics:
  Time(%)  Total Time  Calls  Average  Name
   45.2%   234.5ms     200    1.17ms   cudaStreamSynchronize
   22.1%   114.8ms     200    0.57ms   cudaLaunchKernel
   ...

CUDA Kernel Statistics:
  Time(%)  Total Time  Instances  Average  Name
   28.0%    45.6ms     200        0.23ms   ForeignNode[2]   ← DLA subgraph
   ...

1.4 报告查看

# 命令行统计
nsys stats my_report.nsys-rep

# 导出为 JSON (便于脚本处理)
nsys export --type=json --output=report.json my_report.nsys-rep

# GUI 查看 (在 Windows/Linux PC 上安装 Nsight Systems GUI)
# 下载: https://developer.nvidia.com/nsight-systems
# 从 NX 拷贝 .nsys-rep 文件到 PC 打开
scp nvidia@192.168.31.56:/path/to/report.nsys-rep .

2. trtexec

2.1 Engine 构建

TRTEXEC=/usr/src/tensorrt/bin/trtexec

# GPU FP16
$TRTEXEC --onnx=model.onnx --saveEngine=model_gpu_fp16.engine \
    --fp16 --memPoolSize=workspace:4096MiB

# GPU INT8 (需要校准数据或 PTQ)
$TRTEXEC --onnx=model.onnx --saveEngine=model_gpu_int8.engine \
    --int8 --fp16 --memPoolSize=workspace:4096MiB

# DLA INT8 (DLA core 0, 允许 GPU fallback)
$TRTEXEC --onnx=model.onnx --saveEngine=model_dla0_int8.engine \
    --useDLACore=0 --allowGPUFallback --int8 --fp16 \
    --memPoolSize=workspace:4096MiB

# DLA-GPU Hybrid (指定层设备)
$TRTEXEC --onnx=model.onnx --saveEngine=model_hybrid.engine \
    --useDLACore=0 --allowGPUFallback --int8 --fp16 \
    --memPoolSize=workspace:4096MiB \
    --layerDeviceTypes="/model.10/m/m.0/attn/MatMul:GPU,/model.10/m/m.0/attn/Softmax:GPU"

2.2 Engine Benchmark

# 基本推理测试
$TRTEXEC --loadEngine=model.engine --iterations=500 --warmUp=3000

# 带 layer profiling 的详细测试
$TRTEXEC --loadEngine=model.engine --iterations=200 \
    --dumpProfile --exportProfile=profile.json

# 关键输出指标:
#   Throughput: xxx qps          ← 吞吐量
#   GPU Compute Time: mean=x.xxms  ← 单帧 GPU 计算时间
#   Total Host Walltime: x.xxms    ← 总延迟(含 H2D/D2H)

2.3 Layer 信息导出

# 导出层级信息 (JSON)
$TRTEXEC --onnx=model.onnx --useDLACore=0 --allowGPUFallback --int8 --fp16 \
    --memPoolSize=workspace:4096MiB \
    --dumpLayerInfo --exportLayerInfo=layers.json --skipInference

# 导出层级 timing profile
$TRTEXEC --loadEngine=model.engine --iterations=100 \
    --dumpProfile --exportProfile=timing.json

2.4 DLA-GPU Hybrid 层控制

# --layerDeviceTypes 语法: "layerName:GPU" 或 "layerName:DLA"
# 多层用逗号分隔

# 示例: 将注意力层强制到 GPU
$TRTEXEC --onnx=model.onnx --useDLACore=0 --allowGPUFallback --int8 --fp16 \
    --layerDeviceTypes="/model.10/m/m.0/attn/qkv/conv/Conv:GPU,\
/model.10/m/m.0/attn/Split:GPU,\
/model.10/m/m.0/attn/Transpose:GPU,\
/model.10/m/m.0/attn/MatMul:GPU,\
/model.10/m/m.0/attn/Softmax:GPU" \
    --saveEngine=hybrid.engine

3. tegrastats

3.1 基本用法

# 实时监控 (1 秒刷新)
tegrastats

# 自定义刷新间隔 (毫秒)
tegrastats --interval 500

# 输出到文件
tegrastats --interval 1000 --logfile /tmp/tegra_log.txt &

3.2 输出字段说明

RAM 6543/15823MB   ← 内存使用/总量
GR3D_FREQ 76%     ← GPU 利用率
NVDLA0_FREQ 100%  ← DLA0 利用率
NVDLA1_FREQ 85%   ← DLA1 利用率
CPU [20%@2201]     ← CPU 使用率@频率(MHz)
tj: 52C            ← 芯片结温(Thermal Junction)
VDD_CPU_GPU_CV 4500mW  ← CPU/GPU/CV 功耗

4. nvpmodel & jetson_clocks

4.1 性能模式

# 查看当前模式
nvpmodel -q

# 设置为最高性能 (MAXN_SUPER for Orin NX)
sudo nvpmodel -m 0

# 可用模式查看
nvpmodel -p --verbose

4.2 频率锁定

# 锁定所有时钟到最高频率 (benchmark 必须)
sudo jetson_clocks

# 查看当前频率状态
sudo jetson_clocks --show

# 恢复默认 (dynamic scaling)
sudo jetson_clocks --restore

5. VPI Profiling

5.1 VPI Python 基准测试

import vpi, numpy as np, time

W, H = 1280, 720
src = vpi.asimage(np.random.randint(0, 255, (H, W), dtype=np.uint8))
warp = vpi.WarpMap(vpi.WarpGrid((W, H)))

for backend in [vpi.Backend.CUDA, vpi.Backend.VIC]:
    # warmup
    for _ in range(30):
        with backend:
            out = src.remap(warp)
        out.cpu()
    # benchmark
    times = []
    for _ in range(200):
        t0 = time.perf_counter()
        with backend:
            out = src.remap(warp)
        out.cpu()
        times.append((time.perf_counter() - t0) * 1000)
    times.sort()
    print(f"{backend}: avg={sum(times)/len(times):.3f}ms min={times[0]:.3f}ms")

5.2 VPI 支持的后端

后端	硬件	说明
`VPI_BACKEND_CUDA`	GPU CUDA Cores	通用计算，延迟最低
`VPI_BACKEND_PVA`	PVA (Programmable Vision Accelerator)	图像处理专用，功耗低
`VPI_BACKEND_VIC`	VIC (Video Image Compositor)	视频处理专用，带宽优化
`VPI_BACKEND_NVENC`	NVENC (Video Encoder)	编码专用
`VPI_BACKEND_CPU`	CPU	最慢，调试用

Remap 操作支持: CUDA, VIC, CPU（不支持 PVA）

5.3 VPI 在 Pipeline 中的硬件分配

当前 stereo_3d_pipeline 中的 VPI 调用：

操作	后端	硬件	延迟
Remap (双目校正) L+R	CUDA	GPU	~2.8ms (dual)
ConvertImageFormat (NV12→Gray)	CUDA	GPU	~0.1ms
TemporalNoiseReduction	CUDA	GPU	~0.5ms (如启用)

6. 常用 Benchmark 流程

完整性能测试流程

# 1. 设置最高性能模式
sudo nvpmodel -m 0
sudo jetson_clocks

# 2. 预热系统 (运行 5 秒空闲)
sleep 5

# 3. TRT Engine benchmark
/usr/src/tensorrt/bin/trtexec --loadEngine=model.engine \
    --iterations=500 --warmUp=3000 --avgRuns=10

# 4. Pipeline 全链路测试
cd /home/nvidia/NX_volleyball/stereo_3d_pipeline
timeout 15 ./build/stereo_pipeline -c config/pipeline_triple.yaml

# 5. nsys 全链路 profiling
nsys profile --stats=true -o pipeline_profile \
    timeout 10 ./build/stereo_pipeline -c config/pipeline_triple.yaml

# 6. 同时监控系统状态
tegrastats --interval 200 --logfile /tmp/bench_tegra.log &

Benchmark 注意事项

始终锁定频率：jetson_clocks 必须在测试前执行，否则 DVFS 导致结果不稳定
充分预热：TRT engine 首次推理较慢（JIT 优化），至少 warmUp 2-3 秒
温度影响：长时间运行会导致 thermal throttling，关注 tj 温度
DLA 独立计时：DLA 延迟不反映在 GPU Compute Time 中，需要用 nsys 或 --dumpProfile 查看
内存带宽竞争：DLA 和 GPU 共享 LPDDR5 带宽，同时使用会互相影响

jtop JetPack 版本识别修复指南

问题描述

在 Jetson Orin NX（JetPack 6.2, L4T R36.4.7）上运行 jtop 时，JetPack 版本显示为 MISSING。
系统实际已正确安装 nvidia-jetpack 6.2.1+b38。

根因分析

jtop（jetson-stats 4.3.2）使用内部映射表将 L4T 版本号映射到 JetPack 版本。
映射表位于：

/usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py


该表包含 `"36.4.3": "6.2"` 等条目，但 **缺少 `"36.4.7"` 对应条目**。
当 L4T 版本为 R36.4.7 时，查表失败，显示 MISSING。

## 验证步骤

```bash
# 1. 确认 L4T 版本
cat /etc/nv_tegra_release
# 应输出: # R36 (release), REVISION: 4.7, ...

# 2. 确认 JetPack 已安装
dpkg -l | grep nvidia-jetpack
# 应显示: nvidia-jetpack 6.2.1+b38

# 3. 检查 jtop 映射表
grep "36.4" /usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py
# 如果只有 "36.4.3": "6.2"，没有 "36.4.7"，则确认问题

修复方法

向映射表中添加 "36.4.7": "6.2" 条目：

# 备份原文件
sudo cp /usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py \
       /usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py.bak

# 在 "36.4.3": "6.2" 之前插入 "36.4.7": "6.2"
sudo python3 -c "
path = '/usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py'
with open(path, 'r') as f:
    content = f.read()

old = '\"36.4.3\": \"6.2\"'
new = '\"36.4.7\": \"6.2\",\n    \"36.4.3\": \"6.2\"'
content = content.replace(old, new)

with open(path, 'w') as f:
    f.write(content)
print('Patched successfully')
"

# 重启 jtop 服务
sudo systemctl restart jtop.service

验证修复

# 检查映射是否已添加
grep "36.4.7" /usr/local/lib/python3.10/dist-packages/jtop/core/jetson_variables.py
# 应输出包含 "36.4.7": "6.2" 的行

# 运行 jtop 确认
jtop
# JetPack 应显示为 6.2 而非 MISSING

cloudflare加速onedrive文件下载

2025-12-27T05:52:03.010Z

cloudflare加速onedrive文件下载

lyc8503/onedrive-cf-index-ng: Another OneDrive public directory listing on Docker / Cloudflare Workers, forked from onedrive-vercel-index.

开始

首先fork仓库到本地，fork后不可转私有，可以先download下再自建私有库。

快速开始Getting started - OneDrive Vercel Index（注：该配置文档为OneDrive-Vercel-Index项目，现在配置项目onedrive-cf-index-ng为该项目二开，具体配置差异以onedrive-cf-index-ng文档为主。）

修改config/site.config.js

userPrincipalName- 用于验证你的身份,需要与认证的onedrive用户名一致。
baseDirectory使用 OneDrive-vercel-index 共享的基础文件夹，设置共享目录可防止其他文件在互联网上公开。

修改config/api.config.js

如果你是 OneDrive 国际版用户（不是 OneDrive 商务或教育版，也不是 SharePoint 用户，也不是 Microsoft 365 E5 用户），你可以忽略这一步，保持不动。

OneDrive 世纪互联用户的 API 路由与我们通常使用的不同，你需要更改并：authApi``driveApi

把它们改成：

1 2	authApi: "https://login.partner.microsoftonline.cn/common/oauth2/v2.0/token", driveApi: "https://microsoftgraph.chinacloudapi.cn/v1.0/me/drive",

OneDrive 商务、教育账户和 E5 订阅账户需要确认是否有管理员权限

配置可访问Advanced - OneDrive Vercel Index

开始配置Azure应用

Microsoft Azure 应用注册（适用于 OneDrive 国际版、OneDrive 商务版或教育版），或者…
Microsoft Azure.cn 应用注册（OneDrive 世纪互联版本）

参考密钥配置文档：高级版 - OneDrive Vercel 索引

用你的 Microsoft 账户登录，选择新注册。

创建应用随意名称my-onedrive-vercel-index

将支持账户类型设置为：

1
2

Accounts in any organizational directory (Any Azure AD directory - Multitenant) and personal Microsoft accounts (e.g. Skype, Xbox)
任何组织目录(任何 Microsoft Entra ID 租户 - 多租户)中的帐户和个人 Microsoft 帐户(例如 Skype、Xbox)

将重定向URI（可选）设置为Web和（URL）http://localhost

获取你的客户身份证和密钥

应用程序(客户端) ID即为配置config/api.config.js中的module.exports/clientId

创建密钥，时间尽量拉长，最后，点击添加，复制client_secret的值（你只有这一次复制机会）。

将得到的密钥在高级版 - OneDrive Vercel 索引中加密，得到类似于U2FsdGVkX1830zo3/pFDqaBCVBb37iLw3WnBDWGF9GIB2f4apzv0roemp8Y+iIxI3Ih5ecyukqELQEGzZlYiWg==的值。

该值即为配置config/api.config.js中的module.exports/obfuscatedClientSecret

cloudflare部署

入门 ·lyc8503/onedrive-cf-index-ng 维基

进入 Cloudflare Dashboard

https://dash.cloudflare.com

创建 Pages 项目（注意是pages不是woker）

左侧菜单 → Workers & Pages → Create application → Connect to Git
选择你的 Fork 仓库（如 yourname/onedrive-cf-index-ng）
分支：main
构建设置：设置为Next.js即可

部署完成后应该会显示：xxx.pages.dev``Error: Could not access built-in Node.js modules. Please make sure that your Cloudflare Pages project has the 'nodejs_compat' compatibility flag set.

需要添加标志和KV

兼容性标志：设置为nodejs_compat
创建KV储存库并且绑定

完成配置后重新部署即可

重新部署后应该能够正确访问，接下来是OneDrive绑定认证

Getting started - OneDrive Vercel Index

RDK S100P的种种

2025-12-27T00:27:09.891Z

资料

dtop

Jetson有Jtop,Linux有Htop,RDK也有Dtop！ - 板卡使用 - 地瓜机器人论坛

模型性能调优 - OpenExplorer

参考教程

万字长文，学妹吵着要学的RDKS100模型量化及部署，你确定不学？ - SkyXZ - 博客园

官方示例猴子脚本

rdk_model_zoo_s/samples/Vision/Ultralytics_YOLO/x86/export_monkey_patch.py at s100 · D-Robotics/rdk_model_zoo_s

官方示例量化脚本

rdk_model_zoo_s/samples/Vision/Ultralytics_YOLO/x86/mapper.py at s100 · D-Robotics/rdk_model_zoo_s

官方示例量化配置yaml

rdk_model_zoo_s/samples/Vision/ultralytics_YOLO_Detect/source/reference_yamls/config_ultralytics_YOLO_Detect_YUV420SP_NV12.yaml at s100 · D-Robotics/rdk_model_zoo_s

环境部署

万字长文，学妹一看就会的RDKS100模型量化及部署_rdk s100-CSDN博客

不推荐手动部署，建议直接bash ./run_docker.sh data/

模型量化

这部分容易出错，建议先跑跑官方示例练练手。

需要着重注意量化配置中，各种输入输出格式，颜色通道。

yolov8模型量化(示例)

待完善。。。

万字长文，学妹吵着要学的RDKS100模型量化及部署，你确定不学？ - SkyXZ - 博客园

yolov11模型量化

首先准备yolov11模型

转onnx

# yolo11_to_onnx.py
from ultralytics import YOLO

# 加载你训练好的 YOLOv11 模型
pt_file = "best.pt"

model = YOLO(pt_file)

# 导出 ONNX（RDK S100 兼容模式）
model.export(
    format="onnx",
    imgsz=640,          # 必须和训练时一致
    batch=1,            # 固定 batch=1（RDK 推荐）
    opset=11,           # 必须为 11！
    dynamic=False,      # 关闭动态 shape（避免 BPU 不支持）
    simplify=True,      # 优化图（移除冗余节点）
    nms=False,          # 先不带 NMS（RDK BPU 可能不支持 NonMaxSuppression）
    device="cpu"        # 导出时用 CPU 避免 GPU 干扰
)

print(f"✅ YOLOv11 ONNX 已生成: {pt_file.replace('.pt', '.onnx')}")

hb_compile算子检测

使用hb_compile检测BPU算子支持,S100 用 nash-e，S100P 用 nash-m

hb_compile \
  --march nash-m \
  --model ./best.onnx \
  --input-shape images 1x3x640x640

算子测试表格中需要查看是否所有算子都被BPU，VPU支持，--表示算子被前后融合计算，是正常情况，需要留意的是是否存在CPU算子，性能损失见模型性能调优 - OpenExplorer

算子不支持

模型性能调优 - OpenExplorer

S100 Torch算子BPU约束列表 - OpenExplorer

算子不支持是BPU常态，若退回CPU执行，将会导致模型性能严重降低。

CPU算子处于模型中部
对于CPU算子处于模型中部的情况，建议您优先尝试参数调整、算子替换或修改模型。
CPU算子处于模型首尾部
对于CPU算子处于模型首尾部的情况，请参考以下示例，下面以量化/反量化节点为例：

邪恶C2PSA算子

例如在yolov11中，模型架构为

# YOLO11n backbone
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, False, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, False, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
  - [-1, 2, C2PSA, [1024]] # 10

# YOLO11n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, False]] # 13

  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 2, C3k2, [256, False]] # 16 (P3/8-small)

  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 13], 1, Concat, [1]] # cat head P4
  - [-1, 2, C3k2, [512, False]] # 19 (P4/16-medium)

  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 10], 1, Concat, [1]] # cat head P5
  - [-1, 2, C3k2, [1024, True]] # 22 (P5/32-large)

  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

其中的C2PSA正是导致模型算子不能被bpu完全支持，对于处于中部的邪恶C2PSA算子只能使用替换模型的方式。

C2PSA（Cross Stage Partial with Pyramid Squeeze Attention）是YOLO11新增的核心模块，结合CSP结构与注意力机制：

CSP 结构 (Cross Stage Partial)****：特征分流，一部分走深层网络，一部分直接连接。 -> 所有方案都通过 C3k2 实现了这一点。
Pyramid (金字塔/多尺度感知)：原模型通过不同核大小的卷积或分层处理来获取不同感受野。
PSA (Position-Sensitive Attention)：位置敏感注意力，关注“哪里是重点”以及“哪个通道是重点”。

替换方案

纯 C3k2 方案

结构：[-1, 3, C3k2, [1024, True]]

优点：速度最快，完全无缝兼容 BPU。

缺点：严重缺失注意力机制。它只是单纯加深了网络，依靠卷积层的堆叠来“隐式”地学习特征，没有显式地告诉网络“去关注某个位置”。

还原度：50%。只保留了 CSP 和卷积提取，丢失了 C2PSA 的灵魂（Attention）。

C3k2 + CBAM 方案

结构：C3k2 + CBAM(k=7)

优点：CBAM 包含 CAM (通道注意力) 和 SAM (空间注意力)。其中 SAM 使用 7x7 卷积，能够提供较好的局部空间感知。

缺点：CBAM 的空间注意力是基于 7x7 局部窗口 的，它能看到周围一圈，但很难像 PSA 那样捕捉长距离（Long-range） 的依赖关系。

还原度：80%。补全了空间和通道注意力，但在“全局位置感知”上略逊一筹。

C3k2 + CoordAtt 方案 (理论最佳匹配)

结构：C3k2 + CoordAtt

核心优势：C2PSA 的核心词是 “Position-Sensitive” (位置敏感)。

CoordAtt 的原理：它通过分别对 X 轴 和 Y 轴 进行全局池化，将全局的空间信息编码进两个方向的向量中。

对比 PSA：这与 PSA 试图建立长距离位置依赖的目标高度一致。相比 CBAM 的 7x7 局部视野，CoordAtt 拥有全图视野 (Global View)，能更好地感知物体在画面中的绝对位置。

BPU 兼容性：极佳（Pool + 1x1 Conv）。

还原度：90%。这是在功能原理上最接近 PSA 的 BPU 友好型算子。

C3k2 + DWConvblock + CBAM 方案 (结构最全)

结构：C3k2 (特征) + DWConv(7x7) (大感受野) + CBAM (注意力)

核心优势：这个组合是物理级堆叠。

用 C3k2 还原 CSP。

用 DWConvblock(7x7) 还原 Pyramid (大卷积核模拟多尺度/大感受野)。

用 CBAM 还原 Attention。

缺点：太重了。Backbone 末端本身通道数就大 (1024)，再串联三个模块，计算量（FLOPs）和延迟（Latency）会显著增加。虽然功能最全，但可能导致 FPS 下降较多。

还原度：95% (功能上最全，但效率最低)。

替换算子后模型全部支持BPU运算。

替换模型后onnx导出

更换部分算子后，需要手动添加ultralytics不包含的class，由于ultralytics不包含手动修改的算子，所以需要修改前面的onnx导出代码。

import sys
import types
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import math
import numpy as np
import itertools
import einops
from einops import rearrange
from timm.models.layers import trunc_normal_

# 假设你需要用到 Conv 和 autopad，如果报错找不到，这里做一个简单的 mock
# 或者你可以从 ultralytics 导入它们
try:
    from ultralytics.nn.modules.conv import Conv, autopad
except ImportError:
    # 简单的 fallback 实现，防止报错
    def autopad(k, p=None, d=1):
        if d > 1:
            k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]
        if p is None:
            p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
        return p

    class Conv(nn.Module):
        def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
            super().__init__()
            self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), dilation=d, groups=g, bias=False)
            self.bn = nn.BatchNorm2d(c2)
            self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
        def forward(self, x):
            return self.act(self.bn(self.conv(x)))

# ==============================================================================
# 1. 在这里粘贴你提供的所有 Attention 类定义 (为了节省篇幅，我只列出 CoordAtt)
#    请务必把你上面发给我的那一大段代码完整粘贴替换下面的区域！
# ==============================================================================

# --------------- 粘贴开始 ---------------

# 这里必须包含 h_swish 和 h_sigmoid，因为 CoordAtt 用到了
class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6

class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

# 你的 CoordAtt 类
class CoordAtt(nn.Module):
    def __init__(self, inp, reduction=32):
        super(CoordAtt, self).__init__()
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))

        mip = max(8, inp // reduction)

        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(mip)
        self.act = h_swish()

        self.conv_h = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)

    def forward(self, x):
        identity = x

        n, c, h, w = x.size()
        x_h = self.pool_h(x)
        x_w = self.pool_w(x).permute(0, 1, 3, 2)

        y = torch.cat([x_h, x_w], dim=2)
        y = self.conv1(y)
        y = self.bn1(y)
        y = self.act(y)

        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)

        a_h = self.conv_h(x_h).sigmoid()
        a_w = self.conv_w(x_w).sigmoid()

        out = identity * a_w * a_h

        return out


class DWConvblock(nn.Module):
    "Depthwise conv + Pointwise conv"

    def __init__(self, in_channels, out_channels, k, s):
        super(DWConvblock, self).__init__()
        self.p = k // 2
        self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=k, stride=s, padding=self.p, groups=in_channels,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

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


# ... (请务必把 EMA, SimAM 等其他所有你可能用到的类都粘在这里，以防万一) ...
# 如果你确定只用了 CoordAtt，那上面这些就够了。如果不确定，建议全部粘贴。

# --------------- 粘贴结束 ---------------


# ==============================================================================
# 2. 核心欺骗步骤：构造虚拟模块
# ==============================================================================

# 创建一个虚拟的 module 对象
fake_attention_module = types.ModuleType('ultralytics.nn.modules.attention')

# 将定义好的类挂载到这个虚拟 module 上
fake_attention_module.CoordAtt = CoordAtt
fake_attention_module.h_swish = h_swish
fake_attention_module.h_sigmoid = h_sigmoid
# 如果还有其他类，例如 fake_attention_module.EMA = EMA

# 将虚拟 module 注入系统 sys.modules
# 这样 PyTorch 加载模型时寻找 'ultralytics.nn.modules.attention' 就会找到这里
sys.modules['ultralytics.nn.modules.attention'] = fake_attention_module


# 导入 DWConvblock 到 ultralytics.nn.modules.block 中
import ultralytics.nn.modules.block
ultralytics.nn.modules.block.DWConvblock = DWConvblock
# ==============================================================================
# 3. 正常执行 YOLO 导出逻辑
# ==============================================================================

from ultralytics import YOLO

if __name__ == '__main__':
    # 加载你训练好的 YOLOv11 模型
    pt_file = "model/yolo11_C2PSAtoC3k2_DWConvblock_CBAM-RGB/best.pt"  # ← 改成你的 .pt 路径

    model = YOLO(pt_file)

    # 导出 ONNX（RDK S100 兼容模式）
    model.export(
        format="onnx",
        imgsz=640,          # 必须和训练时一致
        batch=1,            # 固定 batch=1（RDK 推荐）
        opset=11,           # ⚠️ 必须为 11！
        dynamic=False,      # 关闭动态 shape（避免 BPU 不支持）
        simplify=True,      # 优化图（移除冗余节点）
        nms=False,          # 先不带 NMS（RDK BPU 可能不支持 NonMaxSuppression）
        device="cpu"        # 导出时用 CPU 避免 GPU 干扰
    )

    print(f"✅ YOLOv11 ONNX 已生成: {pt_file.replace('.pt', '.onnx')}")

生成校验数据

注意此处生成校验数据容易出错，请仔细核对。

import numpy as np
import cv2
import os
import glob
import random

def preprocess_image(image_path, target_size=(640, 640)):
    # 1. 读取 (BGR, 0-255)
    img = cv2.imread(image_path)
    if img is None:
        return None
  
    # 2. Resize
    img = cv2.resize(img, target_size)
  
    # 3. 转换色空间 BGR -> RGB 
    # (YOLO需要RGB，我们在脚本里转好，然后在 YAML 里告诉工具这是 RGB)
    img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) 
  
    # 4. HWC 转 CHW (Layout: NCHW)
    img = img.transpose(2, 0, 1)
  
    # 5. 要除以 255.0！保持 0-1 的数值范围
    # 归一化
    img = img.astype(np.float32) / 255.0
  
    return img

# 创建保存目录
save_dir = "./calibration_data"
os.makedirs(save_dir, exist_ok=True)

# 获取图片
all_images = glob.glob(os.path.join("./", "*.jpg")) # 确保路径对

# 随机选取 
if len(all_images) > 100:
    image_list = random.sample(all_images, 100)
else:
    image_list = all_images

print(f"Start processing {len(image_list)} images...")

for i, img_path in enumerate(image_list):
    processed_data = preprocess_image(img_path)
    if processed_data is not None:
        # 保存
        np.save(os.path.join(save_dir, f"{i}.npy"), processed_data)

print("Done.")

hb_compile量化工具

直接量化，快速性能评测模式（开启fast-perf），会转为int8-NV12模型。（建议还是添加校验数据的手动校准，详细参考官方文档）

hb_compile --fast-perf \
           --model /open_explorer/data/best.onnx \
           --march nash-m \
           --input-shape images 1x3x640x640

自定义量化

创建yolo11_quantize.yaml

# 模型参数组
model_parameters:
  onnx_model: "best.onnx"
  march: "nash-m"                     # S100P 用 nash-m，S100 用 nash-e
  output_model_file_prefix: "yolo11_bgr"
  working_dir: "./model_output"

# 输入信息参数组
input_parameters:
  input_name: "images"                # ONNX 模型的输入节点名（用 netron 查看）
  input_type_train: "rgb"             # 校准数据是rgb
  input_type_rt: "bgr"                # 运行时也用 BGR（关键！）
  input_layout_train: "NCHW"          # YOLOv8/v11 通常是 NCHW
  input_shape: "1x3x640x640"          # 根据你的模型实际输入改
  input_batch: 1
  mean_value: "0 0 0"                 # 如果训练时没减均值，就设为 0
  scale_value: "0.003921568627451"    # = 1/255，如果训练时归一化到 [0,1]

# 校准参数组
calibration_parameters:
  cal_data_dir: "./calibration_data"        # 必须存在且包含校准图片（BGR 格式）
  # 强制指定一种校准方法，不要让它搜索
  calibration_type: 'max'     # 对于检测任务，max 通常最稳
  max_percentile: 0.99995
  per_channel: False          # YOLO 通常不需要逐通道量化，False 更快且兼容性好

# 编译参数组
compiler_parameters:
  compile_mode: "latency"
  core_num: 1
  optimize_level: "O2"
  jobs: 4                     # 并行编译线程数

允许hb_compile --config yolo11_quantize.yaml

Calibrated Cosine表示优化后模型（optimized_float_model.onnx）与校准后模型（calibrated_model.onnx）对应节点（Node）/输出Tensor（Output Tensor）的余弦相似度结果。
Quantized Cosine表示优化后模型（optimized_float_model.onnx）与模型量化后生成的定点模型（quantized_model.bc）对应节点（Node）/输出Tensor（Output Tensor）的余弦相似度结果。

注意此处余弦相似度，一般情况需要大于95%，若出现30%等异常低值，请检查测试集生成是否正确(图像通道对应，归一化对应，图片质量)

量化进阶

官方示例位于开发板/app/cdev_demo/bpu/02_detection_sample/02_ultralytics_yolo11路径下，使用的默认coco模型结构如下

2026-01-04 15:21:09,745 INFO ############# Model input/output info #############
2026-01-04 15:21:09,745 INFO NAME      TYPE   SHAPE            DATA_TYPE
2026-01-04 15:21:09,745 INFO --------- ------ ---------------- ---------
2026-01-04 15:21:09,745 INFO images_y  input  [1, 640, 640, 1] UINT8
2026-01-04 15:21:09,745 INFO images_uv input  [1, 320, 320, 2] UINT8
2026-01-04 15:21:09,745 INFO output0   output [1, 80, 80, 80]  FLOAT32
2026-01-04 15:21:09,745 INFO 499       output [1, 80, 80, 64]  INT32
2026-01-04 15:21:09,745 INFO 513       output [1, 40, 40, 80]  FLOAT32
2026-01-04 15:21:09,745 INFO 521       output [1, 40, 40, 64]  INT32
2026-01-04 15:21:09,745 INFO 535       output [1, 20, 20, 80]  FLOAT32
2026-01-04 15:21:09,745 INFO 543       output [1, 20, 20, 64]  INT32

输入为MIPI 摄像头/ISP 输出的原始视频流 NV12 (YUV420sp)

输出为原始特征图。 Box: DFL 分布 (64通道),Cls: 分类概率

切其最后检测头的原因可能是，YOLO 的 Detect 头包含大量的 Transpose（维度变换）、Softmax（指数运算）和巨大的 Concat（拼接）。不适宜BPU结构运算而且数值极度敏感不适合量化。

查看官方模型

参考教程

万字长文，学妹吵着要学的RDKS100模型量化及部署，你确定不学？ - SkyXZ - 博客园

官方示例猴子脚本

rdk_model_zoo_s/samples/Vision/Ultralytics_YOLO/x86/export_monkey_patch.py at s100 · D-Robotics/rdk_model_zoo_s

官方示例量化脚本

rdk_model_zoo_s/samples/Vision/Ultralytics_YOLO/x86/mapper.py at s100 · D-Robotics/rdk_model_zoo_s

官方示例量化配置yaml

rdk_model_zoo_s/samples/Vision/ultralytics_YOLO_Detect/source/reference_yamls/config_ultralytics_YOLO_Detect_YUV420SP_NV12.yaml at s100 · D-Robotics/rdk_model_zoo_s

为了保持与官方示例一致，我们查看官方模型

1	hb_model_info yolo11n_detect_nashe_640x640_nv12.hbm

2026-01-04 16:39:47,687 INFO ############# Model input/output info #############
2026-01-04 16:39:47,687 INFO NAME      TYPE   SHAPE            DATA_TYPE
2026-01-04 16:39:47,687 INFO --------- ------ ---------------- ---------
2026-01-04 16:39:47,687 INFO images_y  input  [1, 640, 640, 1] UINT8
2026-01-04 16:39:47,687 INFO images_uv input  [1, 320, 320, 2] UINT8
2026-01-04 16:39:47,687 INFO output0   output [1, 80, 80, 80]  FLOAT32
2026-01-04 16:39:47,687 INFO 499       output [1, 80, 80, 64]  INT32
2026-01-04 16:39:47,687 INFO 513       output [1, 40, 40, 80]  FLOAT32
2026-01-04 16:39:47,688 INFO 521       output [1, 40, 40, 64]  INT32
2026-01-04 16:39:47,688 INFO 535       output [1, 20, 20, 80]  FLOAT32
2026-01-04 16:39:47,688 INFO 543       output [1, 20, 20, 64]  INT32

sunrise@ubuntu:~/main/2026/test_hbm/build$ ./test_hbm_info /opt/hobot/model/s100/basic/yolo11n_detect_nashe_640x640_nv12.hbm
[UCP]: log level = 3
[UCP]: UCP version = 3.7.3
[VP]: log level = 3
[DNN]: log level = 3
[HPL]: log level = 3
[UCPT]: log level = 6

============================================================
  UCP HBM模型测试工具
============================================================
  模型路径: /opt/hobot/model/s100/basic/yolo11n_detect_nashe_640x640_nv12.hbm
  测试推理: 否
  测试内存: 否

============================================================
  Step 1: 加载模型
============================================================
[BPU][[BPU_MONITOR]][281472937720128][INFO]BPULib verison(2, 1, 2)[0d3f195]!
[DNN] HBTL_EXT_DNN log level:6
[DNN]: 3.7.3_(4.2.11 HBRT)
  ✓ 模型加载成功, 耗时: 349 ms

============================================================
  Step 2: 获取模型名称列表
============================================================
  模型数量: 1
  模型[0]: yolo11n_detect_nashe_640x640_nv12

============================================================
  Step 3: 获取模型句柄
============================================================
  ✓ 已获取模型句柄: yolo11n_detect_nashe_640x640_nv12

============================================================
  Step 4: 获取输入输出数量
============================================================
  输入张量数量: 2
  输出张量数量: 6

============================================================
  Step 5: 获取输入张量详细属性
============================================================
  输入名称[0]: images_y

  [输入 Tensor 0]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 640, 640, 1)
  → 张量类型: 3 - HB_DNN_IMG_TYPE_NV12 (NV12图像格式)
  → 量化类型: 0 - NONE (无量化)
  → 量化轴: 0
  → 对齐后字节大小: -1 bytes
  → Stride信息: (-1, -1, 1, 1)
  → 元素总数: 409600
  输入名称[1]: images_uv

  [输入 Tensor 1]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 320, 320, 2)
  → 张量类型: 3 - HB_DNN_IMG_TYPE_NV12 (NV12图像格式)
  → 量化类型: 0 - NONE (无量化)
  → 量化轴: 0
  → 对齐后字节大小: -1 bytes
  → Stride信息: (-1, -1, 2, 1)
  → 元素总数: 204800

============================================================
  Step 6: 获取输出张量详细属性
============================================================
  输出名称[0]: output0

  [输出 Tensor 0]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 80, 80, 80)
  → 张量类型: 7 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 量化类型: 0 - NONE (无量化)
  → 量化轴: 0
  → 对齐后字节大小: 2048000 bytes
  → Stride信息: (2048000, 25600, 320, 4)
  → 元素总数: 512000
  输出名称[1]: 499

  [输出 Tensor 1]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 80, 80, 64)
  → 张量类型: 8 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数)
  → 量化类型: 1 - SCALE (缩放量化)
  → 量化轴: 3
  → 量化缩放信息:
    缩放数据长度: 64
    缩放数据 (前10个): 0.000601, 0.000602, 0.000556, 0.000525, 0.000421, 0.000437, 0.000292, 0.000345, 0.000311, 0.000240 ...
    零点偏移长度: 64
    零点偏移数据 (前10个): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ...
  → 对齐后字节大小: 1638400 bytes
  → Stride信息: (1638400, 20480, 256, 4)
  → 元素总数: 409600
  输出名称[2]: 513

  [输出 Tensor 2]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 40, 40, 80)
  → 张量类型: 7 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 量化类型: 0 - NONE (无量化)
  → 量化轴: 0
  → 对齐后字节大小: 512000 bytes
  → Stride信息: (512000, 12800, 320, 4)
  → 元素总数: 128000
  输出名称[3]: 521

  [输出 Tensor 3]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 40, 40, 64)
  → 张量类型: 8 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数)
  → 量化类型: 1 - SCALE (缩放量化)
  → 量化轴: 3
  → 量化缩放信息:
    缩放数据长度: 64
    缩放数据 (前10个): 0.000665, 0.000668, 0.000629, 0.000470, 0.000367, 0.000359, 0.000328, 0.000411, 0.000298, 0.000340 ...
    零点偏移长度: 64
    零点偏移数据 (前10个): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ...
  → 对齐后字节大小: 409600 bytes
  → Stride信息: (409600, 10240, 256, 4)
  → 元素总数: 102400
  输出名称[4]: 535

  [输出 Tensor 4]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 20, 20, 80)
  → 张量类型: 7 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 量化类型: 0 - NONE (无量化)
  → 量化轴: 0
  → 对齐后字节大小: 128000 bytes
  → Stride信息: (128000, 6400, 320, 4)
  → 元素总数: 32000
  输出名称[5]: 543

  [输出 Tensor 5]
  --------------------------------
  → 有效形状 (validShape):
    维度数量: 4
    形状: (1, 20, 20, 64)
  → 张量类型: 8 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数)
  → 量化类型: 1 - SCALE (缩放量化)
  → 量化轴: 3
  → 量化缩放信息:
    缩放数据长度: 64
    缩放数据 (前10个): 0.000820, 0.000811, 0.000706, 0.000627, 0.000631, 0.000693, 0.000700, 0.000729, 0.000585, 0.000458 ...
    零点偏移长度: 64
    零点偏移数据 (前10个): 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ...
  → 对齐后字节大小: 102400 bytes
  → Stride信息: (102400, 5120, 256, 4)
  → 元素总数: 25600

============================================================
  Step 7: 获取模型描述信息
============================================================
  描述类型: HB_DNN_DESC_TYPE_JSON
  描述大小: 1628 bytes
  描述内容 (前500字符):
  {"BUILDER_VERSION": "3.3.11", "HBDK_VERSION": "4.1.17", "HBDK_RUNTIME_VERSION": null, "HORIZON_NN_VERSION": "2.1.9", "CAFFE_MODEL": null, "PROTOTXT": null, "ONNX_MODEL": "/open_explorer/ws_0508/ws_yolo11n/yolo11n.onnx", "MARCH": "nash-e", "LAYER_OUT_DUMP": "False", "LOG_LEVEL": null, "WORKING_DIR": "/open_explorer/ws_0508/ws_yolo11n/bpu_outputs", "MODEL_PREFIX": "yolo11n_detect_nashe_640x640_nv12", "OUTPUT_NODES": "", "REMOVE_NODE_TYPE": "", "REMOVE_NODE_NAME": "/model.23/cv2.0/cv2.0.2/Conv;/mod

============================================================
  Step 8: 格式分析
============================================================

----------------------------------------
  NV12输入格式分析
----------------------------------------
  ✓ 检测到NV12输入格式
  → 模式: 分离NV12 (Y和UV在不同tensor中)
  → Y平面 (Tensor 0):
      尺寸: 640x640
      大小: 409600 bytes
  → UV平面 (Tensor 1):
      尺寸: 320x320x2
      大小: 204800 bytes

----------------------------------------
  YOLO输出格式分析
----------------------------------------
  ✓ 检测到6输出YOLO格式 (可能是YOLOv8/v11 检测模型)
  → 典型布局: [cls_80x80, bbox_80x80, cls_40x40, bbox_40x40, cls_20x20, bbox_20x20]
  → 输出[0]: (1, 80, 80, 80) → 类别分数 (80 classes) @ 80x80 特征图 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 输出[1]: (1, 80, 80, 64) → bbox回归 (DFL, 4x16) @ 80x80 特征图 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数) (量化)
  → 输出[2]: (1, 40, 40, 80) → 类别分数 (80 classes) @ 40x40 特征图 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 输出[3]: (1, 40, 40, 64) → bbox回归 (DFL, 4x16) @ 40x40 特征图 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数) (量化)
  → 输出[4]: (1, 20, 20, 80) → 类别分数 (80 classes) @ 20x20 特征图 - HB_DNN_TENSOR_TYPE_F16 (16位浮点)
  → 输出[5]: (1, 20, 20, 64) → bbox回归 (DFL, 4x16) @ 20x20 特征图 - HB_DNN_TENSOR_TYPE_S32 (有符号32位整数) (量化)

============================================================
  Step 9: 释放资源
============================================================
  ✓ 资源释放完成

============================================================
  测试完成
============================================================
  所有测试通过！

其去除Detect头，并且保留p3,p4,p5输出精度，由cpu进行后处理。所以在导出onnx模型基础上，我们需要手动添加一步去除detect头部分，以保证Detect精度。

import sys
import types
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
import math
import numpy as np
import itertools
import einops
from einops import rearrange
from timm.models.layers import trunc_normal_
from ultralytics.nn.modules import Detect

# Forward 函数，切去Detect层的cat和decode部分
def split_head_forward(self, x):
    """
    修改后的 Detect 层 Forward 函数。
    不进行 cat 和 decode，直接输出每个 stride 的 cls 和 box 特征图。
    """
    results = []
    # x 是 backbone/neck 输出的特征图列表 (P3, P4, P5 或 P3, P4)
    for i in range(self.nl): 
        # 输入特征 x[i]
  
        # 1. Cls 分支 (Classification)
        # cls: [B, nc, H, W] → [B, H, W, nc] (NHWC)
        cls_feat = self.cv3[i](x[i]).permute(0, 2, 3, 1).contiguous()
  

        # 2. Box 分支 (Regression)
        # bbox: [B, 64, H, W] → [B, H, W, 64] (NHWC)
        box_feat = self.cv2[i](x[i]).permute(0, 2, 3, 1).contiguous()

  
        # 将两个分支加入结果
        # 注意顺序：官方示例看起来是先 Cls 后 Box，或者反过来
        # 根据你的日志: output0(80ch float) 是 Cls, 499(64ch int32) 是 Box
        # 所以我们按这个顺序返回
        results.append(cls_feat)
        results.append(box_feat)
  
    # 返回扁平化的列表，导出 ONNX 时会变成多个输出节点
    return results




# 假设你需要用到 Conv 和 autopad，如果报错找不到，这里做一个简单的 mock
# 或者你可以从 ultralytics 导入它们
try:
    from ultralytics.nn.modules.conv import Conv, autopad
except ImportError:
    # 简单的 fallback 实现，防止报错
    def autopad(k, p=None, d=1):
        if d > 1:
            k = d * (k - 1) + 1 if isinstance(k, int) else [d * (x - 1) + 1 for x in k]
        if p is None:
            p = k // 2 if isinstance(k, int) else [x // 2 for x in k]
        return p

    class Conv(nn.Module):
        def __init__(self, c1, c2, k=1, s=1, p=None, g=1, d=1, act=True):
            super().__init__()
            self.conv = nn.Conv2d(c1, c2, k, s, autopad(k, p, d), dilation=d, groups=g, bias=False)
            self.bn = nn.BatchNorm2d(c2)
            self.act = nn.SiLU() if act is True else (act if isinstance(act, nn.Module) else nn.Identity())
        def forward(self, x):
            return self.act(self.bn(self.conv(x)))

# ==============================================================================
# 1. 在这里粘贴你提供的所有 Attention 类定义 (为了节省篇幅，我只列出 CoordAtt)
#    请务必把你上面发给我的那一大段代码完整粘贴替换下面的区域！
# ==============================================================================


# 这里必须包含 h_swish 和 h_sigmoid，因为 CoordAtt 用到了
class h_sigmoid(nn.Module):
    def __init__(self, inplace=True):
        super(h_sigmoid, self).__init__()
        self.relu = nn.ReLU6(inplace=inplace)

    def forward(self, x):
        return self.relu(x + 3) / 6

class h_swish(nn.Module):
    def __init__(self, inplace=True):
        super(h_swish, self).__init__()
        self.sigmoid = h_sigmoid(inplace=inplace)

    def forward(self, x):
        return x * self.sigmoid(x)

# 你的 CoordAtt 类
class CoordAtt(nn.Module):
    def __init__(self, inp, reduction=32):
        super(CoordAtt, self).__init__()
        self.pool_h = nn.AdaptiveAvgPool2d((None, 1))
        self.pool_w = nn.AdaptiveAvgPool2d((1, None))

        mip = max(8, inp // reduction)

        self.conv1 = nn.Conv2d(inp, mip, kernel_size=1, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(mip)
        self.act = h_swish()

        self.conv_h = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)
        self.conv_w = nn.Conv2d(mip, inp, kernel_size=1, stride=1, padding=0)

    def forward(self, x):
        identity = x

        n, c, h, w = x.size()
        x_h = self.pool_h(x)
        x_w = self.pool_w(x).permute(0, 1, 3, 2)

        y = torch.cat([x_h, x_w], dim=2)
        y = self.conv1(y)
        y = self.bn1(y)
        y = self.act(y)

        x_h, x_w = torch.split(y, [h, w], dim=2)
        x_w = x_w.permute(0, 1, 3, 2)

        a_h = self.conv_h(x_h).sigmoid()
        a_w = self.conv_w(x_w).sigmoid()

        out = identity * a_w * a_h

        return out


class DWConvblock(nn.Module):
    "Depthwise conv + Pointwise conv"

    def __init__(self, in_channels, out_channels, k, s):
        super(DWConvblock, self).__init__()
        self.p = k // 2
        self.conv1 = nn.Conv2d(in_channels, in_channels, kernel_size=k, stride=s, padding=self.p, groups=in_channels,
                               bias=False)
        self.bn1 = nn.BatchNorm2d(in_channels)
        self.conv2 = nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=False)
        self.bn2 = nn.BatchNorm2d(out_channels)

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


# ... (请务必把 EMA, SimAM 等其他所有你可能用到的类都粘在这里，以防万一) ...
# 如果你确定只用了 CoordAtt，那上面这些就够了。如果不确定，建议全部粘贴。


# ==============================================================================
# 2. 核心欺骗步骤：构造虚拟模块
# ==============================================================================

# 创建一个虚拟的 module 对象
fake_attention_module = types.ModuleType('ultralytics.nn.modules.attention')

# 将定义好的类挂载到这个虚拟 module 上
fake_attention_module.CoordAtt = CoordAtt
fake_attention_module.h_swish = h_swish
fake_attention_module.h_sigmoid = h_sigmoid
# 如果还有其他类，例如 fake_attention_module.EMA = EMA

# 将虚拟 module 注入系统 sys.modules
# 这样 PyTorch 加载模型时寻找 'ultralytics.nn.modules.attention' 就会找到这里
sys.modules['ultralytics.nn.modules.attention'] = fake_attention_module


# 导入 DWConvblock 到 ultralytics.nn.modules.block 中
import ultralytics.nn.modules.block
ultralytics.nn.modules.block.DWConvblock = DWConvblock
# ==============================================================================
# 3. 正常执行 YOLO 导出逻辑
# ==============================================================================

from ultralytics import YOLO

if __name__ == '__main__':
    # 加载你训练好的 YOLOv11 模型
    pt_file = "model/yolo11_C2PSAtoC3k2_DWConvblock_CBAM-RGB/best.pt"  # ← 改成你的 .pt 路径

    model = YOLO(pt_file)

    # 替换 Detect 层的 forward 方法
    Detect.forward = split_head_forward

    # 导出 ONNX（RDK S100 兼容模式）
    model.export(
        format="onnx",
        imgsz=640,          # 必须和训练时一致
        batch=1,            # 固定 batch=1（RDK 推荐）
        opset=11,           # ⚠️ 必须为 11！
        dynamic=False,      # 关闭动态 shape（避免 BPU 不支持）
        simplify=True,      # 优化图（移除冗余节点）
        nms=False,          # 先不带 NMS（RDK BPU 可能不支持 NonMaxSuppression）
        device="cpu"        # 导出时用 CPU 避免 GPU 干扰
    )

    print(f"✅ YOLOv11 ONNX 已生成: {pt_file.replace('.pt', '.onnx')}")

P3 (Small / 80x80)

P4 (Medium / 40x40)

P5 (Large / 20x20)

工具链量化

检查数据集

import numpy as np
import os

cal_dir = "./calibration_data"
files = sorted([f for f in os.listdir(cal_dir) if f.endswith('.npy')])
print(f"Total calibration files: {len(files)}")

if len(files) == 0:
    print("❌ ERROR: No calibration files found!")
    exit(1)

# 检查前3个文件
for i, fname in enumerate(files[:3]):
    data = np.load(os.path.join(cal_dir, fname))
    print(f"\nFile {i}: {fname}")
    print(f"  Shape: {data.shape}")           # 应该是 (3, 640, 640)
    print(f"  Dtype: {data.dtype}")           # 应该是 float32
    print(f"  Value range: [{data.min():.2f}, {data.max():.2f}]")  # 应该是 [0, 255]
    print(f"  Mean per channel (RGB): R={data[0].mean():.1f}, G={data[1].mean():.1f}, B={data[2].mean():.1f}")
  
    # 验证值范围
    if data.min() < 0 or data.max() > 1:
        print("  ⚠️ WARNING: Value range incorrect!")
    if data.shape != (3, 640, 640):
        print("  ⚠️ WARNING: Shape incorrect!")
    if data.dtype != np.float32:
        print("  ⚠️ WARNING: Dtype incorrect!")

print("\n✅ Verification complete")

# 模型参数组
model_parameters:
  onnx_model: "best.onnx"
  march: "nash-m"                     # S100P 用 nash-m，S100 用 nash-e
  output_model_file_prefix: "yolo11"
  working_dir: "./model_output"
  # remove_node_name: "474;494;514"

# 输入信息参数组
input_parameters:
  input_name: "images"                # ONNX 模型的输入节点名（用 netron 查看）
  input_type_train: "rgb"             # 校准数据是rgb
  input_type_rt: "rgb"                # 运行时也用 BGR（关键！）
  input_layout_train: "NCHW"          # YOLOv8/v11 通常是 NCHW
  input_shape: "1x3x640x640"          # 根据你的模型实际输入改
  input_batch: 1
  scale_value: "0.003921568627451"    # = 1/255，如果训练时归一化到 [0,1]
  norm_type: 'data_scale'


# 校准参数组
calibration_parameters:
  calibration_type: 'default'
  cal_data_dir: "./calibration_data"        # 必须存在且包含校准图片
  cal_data_type: 'float32'
  quant_config: {"op_config": {"softmax": {"qtype": "int8"}}}

# 编译参数组
compiler_parameters:
  extra_params: {'input_no_padding': True, 'output_no_padding': True}
  compile_mode: "latency"
  core_num: 1
  optimize_level: "O2"
  jobs: 16                     # 并行编译线程数

模型推理

51hhh/RDK-S100p-BPU-yolo: RDK

wsl安装isaac gym

2025-11-12T03:04:44.842Z

安装wsl2 ubuntu20.04

1	wsl --install -d Ubuntu-20.04

安装conda

Download Success | Anaconda

1
2
3

mkdir ~/download
cd ~/download
wget https://repo.anaconda.com/miniconda/Miniconda3-latest-Linux-x86_64.sh

1	bash ./Miniconda3-latest-Linux-x86_64.sh

一路默认安装即可

激活环境

1	source ~/.bashrc

安装CUDA

选择与window相同版本的cuda_12.1.0

需要安装历史存档，CUDA版本低于12.1.0

CUDA Toolkit Archive | NVIDIA Developer

wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-keyring_1.0-1_all.deb
sudo dpkg -i cuda-keyring_1.0-1_all.deb
sudo apt-get update
sudo apt-get -y install cuda

查看仓库中所有可安装的 CUDA 版本（以cuda-开头）：

1	apt list \| grep -E '^cuda-[0-9]'

安装该版本 CUDA：

1	sudo apt-get -y install cuda-12-1

安装nvcc

1	sudo apt install cuda-toolkit-12-1

打开配置文件

1	nano ~/.bashrc

在文件最末尾添加以下两行：

1 2	export PATH=/usr/local/cuda-12.1/bin:$PATH export LD_LIBRARY_PATH=/usr/lib/wsl/lib/:$LD_LIBRARY_PATH

保存退出（按 Ctrl+O 回车保存，按 Ctrl+X 退出）。

刷新环境变量使其立即生效：

1	source ~/.bashrc

nvidia-smi

## 查看CUDA版本
nvcc --version

这里的CUDA版本表示GPU 支持的最高 CUDA 版本，并非nvcc版本。

创建conda环境

1 2	conda create -n rl python=3.8.10 conda activate rl

安装对应cuda版本pytorch

在pytorch查询对应cuda版本的pytorch，之前的PyTorch版本

1	conda install pytorch==2.4.1 torchvision==0.19.1 torchaudio==2.4.1 pytorch-cuda=12.1 -c pytorch -c nvidia

验证pytorch

python

1
2
3

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

安装依赖

pip install torchvision -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install torch -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install pyquaternion -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install pyyaml -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install pexpect -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install einops -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install tqdm -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install packaging -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install h5py -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install ipython -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install getkey -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install wandb -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install chardet -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install matplotlib -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install numpy==1.23.2 -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install h5py_cache -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install opencv-python -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install tensorboard -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install onnxruntime

配置ssh

Ubuntu20.04子系统自带的ssh服务无法连接，需卸载后重新安装。

卸载ssh服务

1	apt remove openssh-server

重装ssh服务

1	apt install openssh-server

1	sudo nano /etc/ssh/sshd_config

确保以下配置

Port 22                   # 默认端口
ListenAddress 0.0.0.0     # 允许所有 IP 连接
PasswordAuthentication yes # 启用密码登录
PermitRootLogin yes       # 允许 root 登录（按需调整）
# X11
X11Forwarding yes
X11UseLocalhost no

重启ssh服务

sudo service ssh restart

安装vulkan

教程：【记录】在WSL2中部署Vulkan开发环境（2022年版） - 知乎

在 WSL2 上配置 Isaac Gym 宇树机器人强化学习环境 - ErBW_s - 博客园

使用命令sudo apt-get install xfce4 安装xfce4桌面环境

选择gdm3即可。

1	sudo nano ~/.bashrc

将以下命令添加到bashrc文件末尾：

1 2	export DISPLAY=$(awk '/nameserver / {print $2; exit}' /etc/resolv.conf 2>/dev/null):0 export LIBGL_ALWAYS_INDIRECT=1

1	source ~/.bashrc

完成后使用命令sudo xfce4-session 启动xfce4桌面环境

注意：之后的操作都要在xfce桌面终端执行

安装Vulkan

LunarG VulkanSDK Packages

wget -qO - https://packages.lunarg.com/lunarg-signing-key-pub.asc | sudo apt-key add -
sudo wget -qO /etc/apt/sources.list.d/lunarg-vulkan-1.3.283-focal.list https://packages.lunarg.com/vulkan/1.3.283/lunarg-vulkan-1.3.283-focal.list
sudo apt update
sudo apt install vulkan-sdk

这时运行 vulkaninfo --summary 会发现在使用 CPU (llvmpipe) 而不是 NVIDIA GPU，这是因为 WSL2 内置的 mesa 是 CPU 实现，我们需要使用第三方 mesa 源来启用 GPU

在xfce4终端执行以下命令：

1
2
3

sudo add-apt-repository ppa:kisak/kisak-mesa
sudo apt update
sudo apt upgrade

如果缺失dzn_icd.x86_64.json可以尝试更换ppa源,但是速度较慢

Vulkan Fails to Detect NVIDIA GPU on WSL2 Ubuntu 24.04 - `dzn` Driver Files Missing (Tested on multiple systems) - Graphics / Linux / Linux - NVIDIA Developer Forums

1
2
3

sudo add-apt-repository ppa:kisak/turtle
sudo apt update
sudo apt upgrade

在当前版本命令执行时应该会显示mesa需要更新，更新时速度较慢，耐心等待更新完成后理论上你可以在ls /usr/share/vulkan/icd.d/下找到4个json文件：

1	VK_ICD_FILENAMES=/usr/share/vulkan/icd.d/dzn_icd.x86_64.json vulkaninfo

现在查看vulkaninfo --summary,Vulkan运行时才算是真正调度起了GPU

安装Isaac gym

下载并且解压Isaac Gym - Download Archive | NVIDIA Developer

1	tar -zxvf IsaacGym_Preview_4_Package.tar.gz

1	git clone https://github.com/isaac-sim/IsaacGymEnvs.git

安装依赖

1 2	pip install -e ./isaacgym/python pip install -e ./IsaacGymEnvs

验证isaacgym

python

1 2	import isaacgym quit()

可能遇到无法找到或加载其运行所需的 NVIDIA CUDA 动态链接库 (libcuda.so 或类似文件) 以及 PhysX 物理引擎库

寻找对应的库文件并复制到 /usr/lib/x86_64-linux-gnu 文件夹中

1 2	find / -name libpython3.8.so.1.0 sudo cp /home/rick/miniconda3/envs/rl/lib/libpython3.8.so.1.0 /usr/lib/x86_64-linux-gnu

没有PhysX 物理引擎库，意思是没有安装 Vulkan，安装 Vulkan即可。

测试倒立摆

1	python ./IsaacGymEnvs/isaacgymenvs/train.py task=Cartpole

mujoco

在WSL上安装MuJoCo和mujoco_py_error: opengl version 1.5 or higher required-CSDN博客

安装

mkdir ~/.mujoco
cd ~/.mujoco
wget https://mujoco.org/download/mujoco210-linux-x86_64.tar.gz
tar -zxvf mujoco210-linux-x86_64.tar.gz
export LD_LIBRARY_PATH=~/.mujoco/mujoco200/bin/

运行

1 2	cd ./mujoco210/bin ./simulate ../model/humanoid.xml

不出意外会缺少openGL

安装即可

1 2	sudo apt install libgl1-mesa-dev freeglut3-dev libglu1-mesa-dev sudo apt install libsoil-dev libglm-dev libassimp-dev libglew-dev libglfw3-dev libxinerama-dev libxcursor-dev libxi-dev

测试

1 2	sudo apt install x11-apps mesa-utils glxgears

1	nano ~/.bashrc

添加配置

1 2	export MESA_GL_VERSION_OVERRIDE=3.3 unset LIBGL_ALWAYS_INDIRECT

生效

1	source ~/.bashrc

再次运行mujoco即可

1	./simulate ../model/humanoid.xml

exo

2025-08-26T23:08:40.988Z

exo日常设备在家中运行您自己的 AI 集群

exo-explore/exo：使用日常设备📱💻 🖥️⌚在家中运行您自己的 AI 集群

EXO 根据当前的网络拓扑和可用设备资源对模型进行最佳拆分。这使您能够运行比在任何单个设备上运行更大的模型。

先决条件

Python>=3.12.0 是必需的，因为以前版本中的 asyncio 存在问题。
对于支持 NVIDIA GPU 的 Linux（仅限 Linux，如果不使用 Linux 或 NVIDIA，请跳过）：
- NVIDIA 驱动程序 - 使用nvidia-smi
- CUDA 工具包 - 从 NVIDIA CUDA 指南安装，使用nvcc --version
- cuDNN 库 - 从 NVIDIA cuDNN 页面下载，按照以下步骤验证安装

确保nvidia-smi，nvcc，cuDNN配置正确，缺一不可。

运行 exo 的唯一要求是所有设备上都有足够的内存，以便将整个模型放入内存中。例如，如果您运行的是 llama 3.1 8B （fp16），则所有设备都需要 16GB 内存。以下任何配置都可以工作，因为它们的内存总数超过 16GB：
- 2 个 8GB M3 MacBook Air
- 1 x 16GB NVIDIA RTX 4070 Ti 笔记本电脑
- 2 个 Raspberry Pi 400，每个 4GB RAM（在 CPU 上运行）+ 1 个 8GB Mac Mini
EXO 旨在在具有异构功能的设备上运行。例如，您可以让一些设备配备强大的 GPU，而其他设备则配备集成 GPU 甚至 CPU。添加功能较差的设备会减慢单个推理延迟，但会增加集群的整体吞吐量。

从docker开始

从最简基础镜像nanozoo/python3.12开始

docker pull nanozoo/python3.12:3.12--d46ab4d

启动临时容器

docker run -it --name exo_builder_temp \
  python:3.12 \
  bash

-it: 启动一个交互式（i）终端（t）。
--name exo_builder_temp: 给这个临时容器一个易于识别的名称。
python:3.12: 使用我们指定的基础镜像。
bash: 启动容器后直接进入 Bash shell。

配置exo

进入容器，安装必要的系统工具

apt-get update
apt-get install -y --no-install-recommends \
    git \
    build-essential \
    cmake \
    ca-certificates \
    libffi-dev \
    libssl-dev \
    libgl1

清理 apt 缓存，减小最终镜像大小

1	rm -rf /var/lib/apt/lists/*

创建工作目录

1 2	mkdir -p /exo cd /exo

克隆 EXO 仓库

1 2	git clone https://github.com/exo-explore/exo.git cd exo

安装 EXO 及其 Python 依赖,--no-cache-dir 用于避免在容器内部创建不必要的pip缓存

1	pip install -e . --no-cache-dir

退出容器

exit

提交容器状态为镜像

docker commit \
  -c 'WORKDIR /app/exo' \
  -c 'CMD ["exo"]' \
  exo_builder_temp \
  exo:20250827

1	HF_ENDPOINT=https://hf-mirror.com exo

可以在启动命令前添加环境变量访问hf镜像站

创建macvlan网络

1	docker network create -d macvlan --subnet=192.168.1.0/24 --gateway=192.168.1.1 -o parent=eth0 macnet

docker network create 命令创建了一个新的 Docker 网络，使用了 macvlan 驱动。macvlan 网络允许您将容器连接到物理网络，就像它们是网络上的独立主机一样。您为这个网络指定了以下参数：

-d macvlan：指定网络驱动为 macvlan。
--subnet=192.168.1.0/24：指定网络的子网掩码为 192.168.1.0/24。
--gateway=192.168.1.1：指定网络的网关地址为 192.168.1.1。
-o parent=eth0：指定父接口为 eth0，这是混杂模式下配置的物理网络接口。
macnet：是新创建的 Docker 网络的名称。
确保您选择的子网地址没有被路由器、交换机或其他网络设备使用。如果网关地址已被占用，容器将无法正常通信。

使用ifconfig查看网络设备

查看子网下设备避免冲突，sudo arp-scan -I enp4s0 --localnet

启动容器

# 运行带有 macvlan 网络、GPU 支持和 tinygrad CUDA 环境变量的 EXO 容器
docker run -it  \
    --name exo-node-1 \
    --ip 192.168.124.56 \
    --network macnet \
    --gpus all \
    -e CUDA=1 \
    exo:20250827

Qwen-image

2025-08-17T18:42:39.301Z

Qwen-image

docker部署

安装魔搭社区的modelscope模型管理工具

1	pip install -i https://pypi.tuna.tsinghua.edu.cn/simple modelscope

下载docker镜像

1	modelscope download --model inkcoi/ComfyUI-Qwen-Image --local_dir /home/user/#下载文件位置

镜像文件约40GB,请留有充足储存空间

加载Docker镜像

1	docker load -i ./comfyui-qwen-image-latest.tar

加载镜像为comfyui-qwen-image latest 1c856fa3dfd8 10 days ago 42.5GB

运行docker容器

1	docker run --gpus all -d --name comfyui-qwen -p 8188:8188 comfyui-qwen-image:latest python3 main.py --listen 0.0.0.0

挂载目录

docker run --gpus all -d --name comfyui-qwen -p 8188:8188 \
  -v /home/edzhao/Qwen-image/comfyui_data/models:/ComfyUI/models \
  -v /home/edzhao/Qwen-image/comfyui_data/output:/ComfyUI/output \
  -v /home/edzhao/Qwen-image/comfyui_data/custom_nodes:/ComfyUI/custom_nodes \
  -v /home/edzhao/Qwen-image/comfyui_data/input:/ComfyUI/input \
  comfyui-qwen-image:latest python3 main.py --listen 0.0.0.0

如果没有GPU，可以添加--cpu参数：

手动处理

如何遇到依赖错误导致docker容器直接无法启动

基于这个新的自定义镜像，启动一个临时的、只运行 shell 的容器

1	docker run -it --name comfyui_fix_shell_temp --entrypoint /bin/bash comfyui_my_custom_state:latest

-it: 交互式模式。

--name comfyui_fix_shell_temp: 给这个临时容器命名，方便识别。

--entrypoint /bin/bash: 覆盖镜像的默认启动命令，直接启动 shell 环境。

comfyui_my_custom_state:latest: 使用您刚才创建的自定义镜像。

在**comfyui_fix_shell_temp **中完成修复后，将容器打包为镜像。

1	docker commit f6b773f8bcc7 comfyui_my_custom_state_fixed_final:latest

之后从镜像启动即可。

端口转发和监听

容器需要转发端口，-p 8188:8188

comfyui启动需要python3 main.py --listen 0.0.0.0

ESP CSI 动作分类

2025-08-14T00:50:57.461Z

请输入密码

机器学习——深度学习

2025-07-03T05:51:52.154Z

机器学习

机器学习是一个专门研究和开发能够学习的机器的领域，目标是获得通用人工智能。

机器学习是人工智能的核心领域，目标是让计算机通过数据学习规律并做出预测或决策。其核心逻辑是：从数据中提取特征，通过算法训练模型，实现对未知数据的推断。

分类：包括监督学习（如回归、分类算法）、无监督学习（如聚类、降维）、半监督学习和强化学习等。
关键特征：依赖人工设计的特征工程，例如在图像识别中，需要手动提取边缘、颜色等特征。

本篇是对之前文章的扩展，补充与深化，本人深感过去文章水平有限，仅是为完成工程任务调参了解的，极为片面，浅薄的记录，本文试图作为学习笔记系统性记录✍️本人的学习过程。(ﾉ∇︎〃 )
添加了很多骚话个人理解(´つヮ⊂︎)

前面大多为车轱辘话(╯‵□′)╯︵┻━┻，只需要大致了解概念。可直接跳至算法原理。(ฅ>ω<*ฅ)

序言

~~一些很漂亮很浪漫很有人类探索精神的屁话~~╮(╯▽╰)╭

千百年来，人类试图了解智能的机制，并将它复制到思维机器上。

人类从不满足于让机械或电子设备帮助做一些简单的任务，例如，使
用燧石打火，使用滑轮吊起沉重的岩石，使用计算器做算术。

相反，我们希望能够自动化执行更具有挑战性、相对复杂的任务，如
对相似的照片进行分组、从健康细胞中识别出病变细胞，甚至是来一盘优雅的国际象棋博弈。这些任务似乎需要人类的智能才能完成，或至少需要人类思维中的某种更深层次、更神秘的能力来完成，而在诸如计算器这样简单的机器中是找不到这种能力的。
具有类似人类智能的机器是一个如此诱人且强大的想法，我们的文化
对它充满了幻想和恐惧，如斯坦利·库布里克导演的《2001: A Space
Odyssey》中的HAL 9000（拥有巨大的能力却最终给人类带来了威胁）、动作片中疯狂的“终结者（Terminator）”机器人以及电视剧《Knight Rider》中具有冷静个性的话匣子KITT汽车。

1997年，国际象棋卫冕世界冠军、国际象棋特级大师加里·卡斯帕罗夫
被IBM“深蓝”计算机击败，我们在庆祝这一历史性成就的同时，也担心机
器智能的潜力。

神经网络

机器学习－－神经网络

之前在学习Nanodet模型时，对于神经网络非常浅显的记录

计算机可以以相当快的速度在短时间内执行数亿次数学运算，能够高效的数量海量数据，但是在很长一段时间内，计算机却无法做到人类能够轻易完成的任务，仅通过视觉以极快的速度识别身边的物体，无意识间控制四肢协调平衡运动，等等。

而我们却能够仅仅为大脑提供大概20w的功耗轻易做到复杂的计算机无法完成的任务。不禁让很多人试图再次利用仿生学在计算机上实习以上功能。

~~依旧骚话~~✧(◍˃̶ᗜ˂̶◍)✩

最早的神经网络模型–感知机

那就回到1957年，找到美国心理学家弗兰克·罗森布拉特（Frank Rosenblatt），一个神经生物学和行为学副教授，提出一种单层神经网络模型，旨在模拟生物神经元工作原理，由输入层，隐藏层，和输出层组成。

其非常简单，输入问题，进行计算，得到结果，如果存在差异则更新内部权重，这即是训练过程。

你可能会想“这也没什么了不起的吧！”，~~这确实没什么了不起~~╮(╯▽╰)╭，你是这样想的，我也是。但这是由于当时技术的局限和理论的不完善，其确实是神经网络历史上最早提出的模型之一，也是现代深度学习的先驱，为后来的多层感知机和深度学习模型提供了理论支持，开创了人工神经网络的研究。

神经网络

虽然神经元有各种形式，但是所有的神经元都是将电信号从一端传输到另一端，沿着轴突，将电信号从树突传到树突。然后，这些信号从一个神经元传递到另一个神经元。这就是身体感知光、声、触压、热等信号的机制。来自专门的感觉神经元的信号沿着神经系统，传输到大脑，而大脑本身主要也是由神经元构成的。

我们需要多少个神经元才能执行相对复杂的有趣任务呢？

一般说来，能力非常强的人类大脑有大约1000亿个神经元！一只果蝇
拥有约10万个神经元，能够飞翔、觅食、躲避危险、寻找食物以及执行许多相当复杂的任务。10万个神经元，这个数字恰好落在了现代计算机试图复制的范围内。一只线虫仅仅具有302个神经元，与今天的数字计算机资源相比，简直就是微乎其微！但是一只线虫能够完成一些相当有用的任务，而这任务对于尺寸大得多的传统计算机程序而言却难以完成。

激活函数

观察表明，神经元不会立即反应，而是会抑制输入，直到输入增强，
强大到可以触发输出。你可以这样认为，在产生输出之前，输入必须到达一个阈值。就像水在杯中——直到水装满了杯子，才可能溢出。直观上，这是有道理的——神经元不希望传递微小的噪声信号，而只是传递有意识的明显信号。下图说明了这种思想，只有输入超过了阈值（threshold），足够接通电路，才会产生输出信号。

我们可以改进阶跃函数。下图所示的S形函数称为S函数（sigmoid function）。这个函数，比起冷冰冰、硬邦邦的阶跃函数要相对平滑，这使得这个函数更自然、更接近现实。

$$
f(x) = \frac{1}{1 + e^{-x}}
$$

随着输入 x 的增加，sigmoid 函数的输出会接近 1，但永远不会达到 1。同样，当输入值减小时，S 型函数值函数的输出接近，但永远不会达到 0。

sigmoid 一词通常更广泛地用于指代任何 S 形函数。从技术层面来看，对特定函数$f(x) = \frac{1}{1 + e^{-x}}$来说，更准确的术语是逻辑函数。

sigmoid function是机器学习中重要的激活函数

Sigmoid函数的输出范围是0到1。由于输出值限定在0到1，因此它对每个神经元的输出进行了归一化。
用于将预测概率作为输出的模型。由于概率的取值范围是0到1，因此Sigmoid函数非常合适
梯度平滑，避免跳跃的输出值
函数是可微的。这意味着可以找到任意两个点的Sigmoid曲线的斜率
结果明确，即非常接近1或0。
函数输出不是以0为中心的，这会降低权重更新的效率
Sigmoid函数执行指数运算，计算机运行得较慢。

sigmoid激活函数在神经网络中起到的作用：

引入非线性特性，神经网络基本单元是线性组合（加权求和），部分情况需要映射到非线性解决复杂情况$f(x) = \frac{1}{1 + e^{-x}}$
sigmoid通常用于二分类最后一层，输出结果在0-1之间，将结果解释为“某一类的概率”
反向传播便利性，因为sigmoid函数可导，复合求导可得$\sigma’(x) = \frac{1}{1+e^{-x}} \cdot \frac{e^{-x}}{1+e{-x}} = \sigma(x)(1-\sigma(x))$便于反向传播中梯度计算

其他激活函数

双曲正切激活函数

$$
F(x)=tanh(x)
$$

请注意，S 型函数的范围为 0 到 1，tanh 函数的范围为 -1 到 1

修正线性单元激活函数（简称 ReLU）

$$
F(x)=max(0,x)
$$

ReLU 作为激活函数的效果通常优于 S 型函数或 tanh 等平滑函数，因为它在神经网络训练期间不易受到梯度消失问题的影响。与这些函数相比，ReLU 的计算也更容易。

矩阵

下面是一个简单的全连接层

对于第二层，二层一同时接受一层一和一层二的输出，对于此处简单的计算，我们可以得到$X=(input1w_{1,1})+(input2w_{2,1})$,但是实际上的全连接层需要计算的连接个数众多，使用这种计算方法即不直观，而且串行运算在计算机中运行时消耗许多内存交换以及等待时间，显然，我们需要矩阵运算。

对于第二层神经元接受到的信号强度可以使用$X=W•I$计算，W是权重矩阵，I是输入矩阵，X是输入到第二层的结果矩阵。

$X = [\begin{matrix} w_{1, 1} & w_{2, 1} \\ w_{1, 2} & w_{2, 2} \end{matrix}] [\begin{matrix} i n p u t 1 \\ i n p u t 2 \end{matrix}] = [\begin{matrix} (i n p u t 1 * w_{1, 1} + i n p u t 2 * w_{2, 1}) \\ (i n p u t 1 * w_{1, 2} + i n p u t 2 * w_{2, 2}) \end{matrix}]$

使用矩阵可以清晰描述，并且能够直接计算一层权重。

隐藏层

隐藏层，位于神经网络中间层，即既不作为输入也不作为输出，在中间起连接，传递作用的。

$W_{input_hidden}$是输入层和隐藏层之间的权重,$W_{hidden_output}$是隐藏层和输出层之间的权重

$$
X_{hidden}=W_{input_hidden}•Input
$$

隐藏层的输出可以再使用激活函数。

$$
Output_{hidden} = sigmoid(X_{hidden})
$$

计算输出层权重

$$
X_{output}=W_{hidden_output}•Output_{hidden}
$$

使用激活函数

$$
Output_{output}=sigmoid(X_{output})
$$

神经单元线性关系

神经单元使用激活函数非线性关系

神经网络（Neural Network，NN）是机器学习中的一种算法框架，灵感源于生物神经元，通过多层节点（神经元）连接传递信息，实现复杂映射。

结构：由输入层、隐藏层、输出层组成，层间神经元通过权重连接，通过反向传播算法优化权重。
典型模型：早期的感知机、多层感知机（MLP），但受限于计算能力和数据量，应用范围较窄。

深度学习

深度学习（Deep Learning）本质上是多层神经网络的深化，通过增加网络层数（如几十层到上千层）和复杂结构，实现对数据的自动特征提取和表示学习。

深度学习是神经网络的延伸与升级，计算能力的提升解决了传统神经网络训练算力问题，使得深度学习具有更为复杂的结构，能够实现更为复杂的功能。

自动特征工程：无需人工设计特征，例如CNN可自动提取图像的边缘、纹理等高层特征，RNN可处理序列数据的时序关系。

卷积神经网络（CNN）、循环神经网络（RNN）、Transformer、生成对抗网络（GAN）等，广泛应用于图像识别、自然语言处理、语音识别等领域。

什么是机器学习

使计算机不需要显式编程就能拥有学习能力的研究

机器通过观察某项任务存在的模式，并且试图以某种直接或间接方式模仿。

而直接或间接的区别即分为监督学习和非监督学习

监督学习

数据特点：输入数据（特征）配有明确的标签（Label），即“有标准答案”。
示例：图像分类任务中，每张图片标注“猫”“狗”等类别；房价预测中，房屋特征（面积、位置）对应具体价格。
如线性回归，决策树，SVM，CNN

非监督学习

数据特点：输入数据无标签，仅包含特征，需算法自行发现数据内在结构。
示例：用户行为数据（浏览记录、购买偏好）未标注类别，需通过聚类算法将相似用户分组。
如k-means，PCA，AE

监督学习

本质：通过“输入特征+标签”的标注数据，学习从特征到标签的映射关系（函数），再用训练好的模型对新数据预测。
类比理解：类似学生通过“例题（标注数据）”学习解题规则，再用规则解答新题目。

1.数据要求

必须包含特征（Features）和标签（Labels），如：
图像分类：像素值是特征，“猫/狗”是标签；
房价预测：房屋面积、位置是特征，价格是标签。

2.学习目标

最小化预测值与真实标签的误差，例如：
用线性回归预测房价时，让模型输出的价格与实际价格尽可能接近。

3. 训练流程：

划分训练集、验证集和测试集 → 模型拟合训练数据 → 通过验证集调参 → 用测试集评估泛化能力。

无监督学习

本质：仅通过输入特征（无标签），让模型自主发现数据的内在规律（如相似性、聚类结构、分布模式）。
类比理解：类似人类在没有老师指导的情况下，通过观察事物特征（如颜色、形状）自主将其分组（如将水果按大小、甜度分类）。

主要是聚类和降维

聚类（Clustering）：数据分组

目标：将相似的数据点归为同一簇（Cluster），不同簇间差异明显。
示例：
电商平台根据用户购买行为（浏览记录、消费金额）将用户分群，针对性推送商品；
生物学中按基因表达数据对物种分类。

降维（Dimensionality Reduction）：特征压缩

目标：将高维数据（如上万维特征）映射到低维空间，保留关键信息，减少计算复杂度。

参数学习和非参数学习

机器学习可以分为有无监督，也可分为有无参数

参数学习，即数据服从某种固定分布，通过训练数据学习一组固定数量的参数，用固定参数直接描述数据模型。

非参数学习，即不预设参数数量，依赖数据本身，模型复杂度会随之动态变化。

参数学习：典型算法与原理

线性回归（Linear Regression）

核心：假设输出与输入是线性关系，用参数 \theta 表示权重，通过最小化均方误差（MSE）求解 \theta 。
公式： $y = \theta_0 + \theta_1x_1 + \dots + \theta_nx_n $，参数数量为特征维度+1（固定）。

逻辑回归（Logistic Regression）

核心：在线性回归基础上用Sigmoid函数将输出映射到[0,1]区间，用于二分类，参数含义与线性回归类似。
应用：垃圾邮件分类、疾病预测（是否患病）。

朴素贝叶斯（Naive Bayes）

核心：假设特征条件独立，学习先验概率 P(Y) 和条件概率 P(X|Y) （如高斯朴素贝叶斯假设 P(X|Y) 服从高斯分布）。
参数：存储各类别概率和特征分布参数（如均值、方差），数量固定。

非参数学习：典型算法与原理

K近邻（K-Nearest Neighbors, KNN）

核心：不学习参数，直接存储所有训练样本。预测时找新样本的K个最近邻，根据邻居类别投票（分类）或取均值（回归）。
特点：
无固定参数，K是超参数（需手动调优），模型复杂度随样本量增加而提高；
适合处理图像像素级分类（如MNIST手写数字识别）。

决策树（Decision Tree）

核心：通过递归划分特征空间（如按“年龄>30岁”“收入>5000元”等条件分裂节点），树的深度和节点数由数据决定（非固定参数）。
变种：随机森林（集成多棵决策树，非参数特性更强）。

核密度估计（Kernel Density Estimation, KDE）

核心：不假设数据分布，用核函数（如高斯核）平滑每个数据点的概率密度，整体密度由所有点叠加而成。
应用：估计数据的概率分布（如金融市场收益率的分布预测）。

支持向量机（SVM，非参数视角）

核心：当使用非线性核函数（如RBF核）时，SVM通过将数据映射到高维空间求解分隔超平面，模型复杂度与支持向量数量相关（数据量越大，支持向量可能越多）。

机器学习——神经网络

2025-04-26T18:35:00.559Z

机器学习——神经网络

概念合集

机器学习（1）——绪论 - 知乎

机器学习（2）——线性回归（Linear Regression） - 知乎

机器学习（3）——Logistic回归（Logistic Regression） - 知乎

机器学习（4）——模型评价与正则化 - 知乎

机器学习（5）——神经网络（Neural Network，NN） - 知乎

机器学习（6）——激活函数 - 知乎

通俗易懂（合集）：从函数到神经网络

进阶，概念（漫士沉思录）90分钟！清华博士带你一口气搞懂人工智能和神经网络

（3Blue1Brown）【官方双语】深度学习之神经网络的结构 Part 1 ver 2.0

机器学习的基本流程（从函数到神经网络）

机器学习是要找一个函数，对于给定的输入能给出正确的输出。例如聊天机器人就是输入当前的对话场景，输出机器的应答；语音识别就是输入待辨识的音频，输出对应的文字。

函数（function）

Functions Describe the World ----不是我说的

这个Functions完美的符合了所有点，解释了整个World，这即是早期人工智能符号主义，使用准确的函数准确描述所有结果。

但是现实世界中许多问题无法使用准确的函数描述，只能简化问题，核心思想就是“猜”和“差不多得了”。这即是现代联结主义，希望通过对大脑生理结构复杂性模拟来实现智能。

我们首先提供给机器一个特定的函数 f0 （建模），让机器评价它的好坏，并对它不断进行改进（其过程即是不断的猜），期望最终得到一个最佳的函数 f∗ .

在这个简单的示例中，使用一次函数(模型：Y= wX + b)尽可能接近所有点，但是始终无法通过所有点，那就使用差不多得了，认为现在得到w,b就是最优解。

激活函数（Activation Function）

但是，大多数实际数据并非线性关系，为了简单的将原来的线性函数（Y= wX + b）转化为非线性，可以在原本的函数外层套上一个非线性运算，叫激活函数

F(x) = wX + b ==> F(x) = g(wX + b)

现在，通过添加激活函数g(x)=e^x，能够较好的处理非线性数据关系，实际的激活函数比举例的要复杂一点点。

概念：将原本的复杂F(x)画成图的形状，类似神经元的连接（不要理解为真正生物神经突触连接）叫神经网络，神经元连接过程即为一个函数计算过程。

概念及其简单，不要因为名词陌生而觉得过于高端，理解过后既是及其简单的定义。

输入层：即函数输入。

隐藏层：因为套用多层激活函数，位于中间隐藏起来的层。

输出层：即完成函数计算输出结果。

前向传播：即按照神经网络依次正向计算得到结果的过程。

评估----损失函数（lossfunction）

建模、评价和改进，就是机器学习最基本的三个步骤。 ----不是我说的

建模已经完成，能够完成猜的过程，但是，怎样才能评判猜得好不好呢，那就得指定一个标准来评判谁猜得更好，其依据即为损失函数

损失函数表示的是真实值与预测值的误差，在不断猜的过程中就是调整w,b的值使损失函数最小的优化问题，简单的函数可以求导为0求极值点来找到，而有w,b两个变量即是求各自的偏导。

以上通过线性函数来拟合x,y之间的关系即为线性回归

神经网络的损失函数

线性回归的损失函数一般可以通过求导或求偏导的方式获取其极值点，但是，神经网络通常由线性函数和非线性激活函数多种复杂组合而成，其损失函数也应当是复杂的非线性函数，但是解决的办法却没有那么复杂，只需要一点点猜即可，通过不断的调整w,b再计算损失函数，观察损失函数的变化，是增加还是减小，能得到当前调整的参数对结果的影响，尽可能将损失函数结果变小。

w变化的大小使得损失函数变化的大小即为损失函数对w的偏导，每次只需要让参数向偏导的反方向变化

如图，函数最低点位于（0，0，2）其变量为x,y，在y=0平面上，不断尝试向损失函数关于x的偏导的反方向调整，即可到达最低点。

学习率

每次反反向调整可以添加一个系数进行控制，以控制损失函数沿偏导反向下降速率，而控制变化快慢的系数即为学习率。

在模型训练的不同时候对学习率控制尤为重要，常见的有学习率预热（warmup）和学习率衰减（Learning Rate Decay），在此基础上还有许多对学习率控制的优化器，如Adam与AdamW等，优化器对于模型位于不同位置和情况调整学习率以解决对应问题。

可以直观的理解成，如果当前所处的区域比较平坦（梯度的二阶项很小）则我们可以用较大的学习率来更新，快速走出鞍点，如果当前所处的区域比较陡峭（梯度的二阶项很大），则为了防止梯度爆炸等不稳定的情况发生，我们需要用较小的学习率谨慎地更新。

Adam和AdamW - 知乎

从梯度下降到AdamW一文读懂机器学习优化算法 - 知乎

每天3分钟，彻底弄懂神经网络的优化器（十一）AdamW - 知乎

常用学习率调整策略：Pytorch实现11种常用学习率调整策略(自定义学习率衰减) - 知乎

机器学习-学习率：从理论到实战，探索学习率的调整策略 - 知乎

示例分析：NanoDet训练 | polar-bear～Blog

梯度下降

这些偏导数构成的向量就叫梯度。

不断变化w,d参数，使损失函数逐渐变小的过程就叫梯度下降。

最常见的三种梯度下降算法是：

批量梯度下降（Batch Gradient Descent）
随机梯度下降（Stochastic Gradient Descent, SGD）
小批量梯度下降（Mini-batch Gradient Descent）

在批量梯度下降中，学习率应用于整个数据集，用于计算损失函数的平均梯度。而在随机梯度下降和小批量梯度下降中，学习率应用于单个或一小批样本，用于更新模型参数。

随机梯度下降和小批量梯度下降由于其高度随机的性质，常常需要一个逐渐衰减的学习率，以帮助模型收敛。

梯度下降详解（主观理解+推导证明+例题） - 知乎

反向传播

神经网络中求参数对损失函数偏导可以使用链式法则，即损失函数对w1的偏导为“w1变化一个单位使得a变化多少，a变化一个单位使得^y变化多少，^y变化一个单位使得L变化多少，将三者偏导乘在一起，即得到偏导。

然后从右向左依次求导，然后更新每一层参数，例如计算完^y对w2的偏导（a隐藏层的参数w2，b2），在计算损失函数对w1的偏导时也会用到，即可不用重复计算，而是让值从右向左传播，叫反向传播。

通过从输入x到输出y的前向传播，然后反向传播计算损失函数对每个参数的梯度，如果每个参数向着梯度反方向变化，构成神经网络一次训练。

过拟合

在训练数据上表现良好，对新数据预测泛化能力差的现象叫过拟合

模型学会了过于复杂的方法，以至于将噪声和随机波动一并考虑。

使用更多的数据量（数据增强：旋转，翻转，裁剪，噪声）
提前终止训练
修改损失函数添加惩罚项抑制参数过分增长（正则化：这种方法）
Dropout：训练时丢弃部分参数防止对某些参数过度依赖

在损失函数中添加惩罚项，来抑制模型过分复杂，L1和L2，即惩罚项分别为参数绝对值和和参数平方和，L2在参数大时抑制效果更强。

控制惩罚力度的参数叫正则化系数，控制参数的参数叫超参数。

其他问题

梯度消失
梯度爆炸
收敛速度
计算开销

解决

梯度裁剪
残差网络Resnet
Densenet
权重初始化
归一法
动量法
RMSProp
Adam
mini-batch

矩阵

卷积

若要使用神经网络识别图片，按照像素平铺展开，例如，一个输入为 224x224x3 的图像，如果连接到一个有 1000 个神经元的全连接层，那么参数数量将非常庞大。则这个全连接层参数将超过百万级别，而且像素之间无法保留空间关系，会导致模型不能很好理解图像的局部模式。

卷积层通过卷积核在图像上滑动，并共享卷积核的权重。这意味着无论图像尺寸多大，卷积核的参数数量都是固定的。例如，一个 5x5 的卷积核，只有 25 个参数。

在传统的图像处理中，卷积操作使用一个预先定义好的、固定的矩阵（称为卷积核、滤波器或掩码）在图像上滑动。这个矩阵中的数值决定了卷积操作的行为。

模糊: 使用平均滤波器或高斯滤波器。
锐化: 使用拉普拉斯算子或Sobel算子。
边缘检测: 使用Sobel算子、Prewitt算子或Canny算子。
浮雕: 使用特定的矩阵来模拟光照效果。

卷积操作实际上是计算卷积核与图像局部区域的加权和。通过改变卷积核中的权重，可以突出或抑制图像中的某些特征，从而达到图像处理的目的。

卷积神经网络（Convolutional Neural Network，CNN）

卷积层（Convolution Layer）

在卷积神经网络中，与传统的图像处理不同，CNN（卷积神经网络）中的卷积核不是预先定义的，而是通过机器学习（通常是反向传播算法）从大量数据中学习得到的。CNN 通过训练，不断调整卷积核中的数值，使其能够更好地识别和提取图像中的特征，从而提高图像识别、分类或其他任务的准确性。

卷积层可以替换神经网络中一层全连接层，起到减少权重参数，有效提取局部特征的作用

池化层（Pooling Layer）

与卷积层配合使用的一般还有池化层（Pooling Layer），池化层起到的作用是在保留重要特征的同时，降低特征图的空间维度，从而减少计算量和参数数量。

循环神经网络（Rerrent Neural Network, RNN）

词嵌入（word embedding）

wevi单词嵌入可视化检查器

词嵌入（Word Embedding）是一种将自然语言中的词语映射到低维向量空间的技术。简单来说，就是把每个词都变成一个向量，这个向量能够捕捉到词语的语义信息，使得语义相似的词在向量空间中距离更近。

通过计算两个词向量的点积或者余弦相似度，可以表示向量之间的相关性。

词向量嵌入矩阵潜空间降维投影到坐标系，可视化不同词语之间的距离

Embedding projector - visualization of high-dimensional data

为了将上一词的词义与后文产生联系，可以将第一词的隐藏状态和第二词一起参数运算，依次传递，就可使得后文具有前词的信息。

既是RNN循环神经网络，是一种专门用于处理序列数据的神经网络。与传统的前馈神经网络不同，RNN 具有循环连接，使得它可以将之前的状态信息传递到当前状态，从而能够处理具有时序关系的序列数据。

详细流程如下：

和经典神经网络相比，仅仅是多了一个前一时刻的隐藏状态。

Transformer

Transformer 是一种基于自注意力机制（Self-Attention Mechanism）的神经网络架构，最初由 Google 在 2017 年的论文 “Attention is All You Need” 中提出。它彻底改变了自然语言处理（NLP）领域，并在机器翻译、文本生成、问答系统等任务中取得了显著的成果。

NanoDet训练及部署

2025-04-21T02:34:54.364Z

NanoDet训练

github：RangiLyu/nanodet: NanoDet-Plus⚡Super fast and lightweight anchor-free object detection model. 🔥Only 980 KB(int8) / 1.8MB (fp16) and run 97FPS on cellphone🔥

CPU：guo-pu/NanoDet-PyTorch-CPU: 此代码用于目标检测，模型小，检测速度快速，适合没GPU显卡的嵌入式设备运行，比如“树莓派”、ARM开发板、嵌入式开发板。

hpc203/nanodet-plus-opencv: 分别使用OpenCV、ONNXRuntime部署NanoDet-Plus，包含C++和Python两个版本的程序

目标检测——使用nanodet训练自己制作的数据集并测试模型，通俗易懂（详细图文教程）_nanodet训练自己的模型-CSDN博客

第一模块：深度学习轻量级模型nanodet-CSDN博客

轻量级目标检测模型NanoDet-Plus微调、部署（保姆级教学）-CSDN博客

数据集：

使用Labelimg制作VOC格式数据集或yolo格式数据集（详细图文教程）_yolov5训练集-CSDN博客

conda

添加环境变量

..\anaconda3
..\anaconda3\Scripts
..\anaconda3\Library\bin
..\anaconda3\Library\mingw-w64\bin

查看安装情况

1	conda --version

创建/删除环境
命令创建python版本为X.X、名字为 env_name 的虚拟环境。env_name文件可以在Anaconda安装目录 envs文件下找到。

1	conda create -n env_name python=3.8

在conda环境下，输入以下命令查看当前存在的环境：

1	conda env list

删除环境

1 2	conda remove -n env_name --all conda env remove -n env_name

重命名环境（将 --clone 后面的环境重命名成 -n 后面的名字）

1	conda create -n torch --clone py3 # 将 py3 重命名为 torch

创建完成环境之后，系统会提示如何进入和退出环境，如下

1 2	conda activate env_name # 进入环境 conda deactivate# 退出环境

pytorch

查看CUDA版本nvidia-smi nvcc -V

Previous PyTorch Versions | PyTorch

NanoDet项目需要使用不高于2.00版本的Pytorch,而Pytorch低版本安装需要降低CUDA版本，需要重新安装CUDA 11.7

CUDA旧版存档：CUDA Toolkit Archive | NVIDIA Developer

在下载安装过程中，将https://developer.download.nvidia.com改为https://developer.download.nvidia.cn可以解决下载速度过慢的问题。

最后安装sudo apt-get -y install cuda的过程中，也可以在/etc/apt/sources.list.d修改

1	sudo nano archive_uri-https_developer_download_nvidia_com_compute_cuda_repos_ubuntu2204_x86_64_-jammy.list

成功解决：AssertionError: Torch not compiled with CUDA enabled - 知乎

创建conda环境

1	conda create -n env_name python=3.8

查看环境

1	conda env list

进入环境

1	conda activate PyTorch

安装pytorch

1	conda install pytorch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1 pytorch-cuda=11.7 -c pytorch -c nvidia

测试torch环境

import torch
print(torch.cuda.is_available())
print(torch.cuda.device_count())
print(torch.cuda.get_device_name(0))

NanoDet

此处使用目标检测——使用nanodet训练自己制作的数据集并测试模型，通俗易懂（详细图文教程）_nanodet训练自己的模型-CSDN博客

整合文件链接：https://pan.baidu.com/s/1H_qB7OZKJodtbEImKN_TeQ 提取码：dcj7

NanoDet项目较早需要使用不高于2.00版本的Pytorch，高版本Pytorch去除了部分NanoDet所用方法

1	conda install pytorch==1.13.1 torchvision==0.14.1 torchaudio==0.13.1 pytorch-cuda=11.7 -c pytorch -c nvidia

注意pytorch与torchvision版本对应

pytorch/vision：特定于计算机视觉的数据集、转换和模型

截至现在25/04/22，由于requirements.txt中未对依赖库做版本限制，会导致安装最新稳定版本，导致NanoDet缺少方法，建议以下库指定版本安装

pytorch-lightning = 1.1.8

（图中版本还是过高，在后期train中无法正常允许，需使用1.1.8版本）

修改requirements.txt

Cython
matplotlib
numpy
omegaconf>=2.0.1
onnx
onnx-simplifier
opencv-python
pyaml
pycocotools
pytorch-lightning==1.1.8
tabulate
tensorboard
termcolor
tqdm

安装

1	pip install -r requirements.txt

在项目根目录安装nanodet

1	python setup.py develop

下载模型，测试NanoDet

1	python demo/demo.py video --config ./config/nanodet-plus-m-1.5x_320.yml --model ./model/nanodet-plus-m-1.5x_320.pth --path ./Video/dai.avi

到此环境完成配置

自训练模型

数据集准备

数据标注工具

labelme：

Releases · wkentaro/labelme

深度学习图像标签标注软件labelme超详细教程 - 知乎

labelimg：

使用Labelimg制作VOC格式数据集或yolo格式数据集（详细图文教程）_yolov5训练集-CSDN博客

【教程】标注工具Labelimg的安装与使用 - 知乎

深度学习工具|LabelImg（标注工具）的安装与使用教程_labelimg软件-CSDN博客

先用labelimg或者labelme标注出数据集，数据量过少可以用数据增强生成增加数据量，按照脚本可得到数据增强后的images和xml，分别为图片和目标位置信息。

xml文件记录了图片名称和标注目标名称及在图片中的位置。

可以使用下面代码转化labelme到labelimg的xml格式

# jsonTOxml.py
# 用于将labelme标注的json文件转换为labelimg的VOC格式的xml文件


import os
import json
import xml.etree.ElementTree as ET
from xml.dom import minidom

def json_to_xml(json_path, xml_dir):
    # 读取json文件
    with open(json_path, 'r', encoding='utf-8') as f:
        data = json.load(f)
  
    # 创建XML结构
    annotation = ET.Element('annotation')
  
    # 添加文件夹信息
    folder = ET.SubElement(annotation, 'folder')
    folder.text = 'images'
  
    # 添加文件名
    filename = ET.SubElement(annotation, 'filename')
    filename.text = data['imagePath']
  
    # 添加路径
    path = ET.SubElement(annotation, 'path')
    path.text = os.path.abspath(os.path.join(xml_dir, data['imagePath']))
  
    # 添加来源信息
    source = ET.SubElement(annotation, 'source')
    database = ET.SubElement(source, 'database')
    database.text = 'Unknown'
  
    # 添加图片尺寸
    size = ET.SubElement(annotation, 'size')
    width = ET.SubElement(size, 'width')
    width.text = str(data['imageWidth'])
    height = ET.SubElement(size, 'height')
    height.text = str(data['imageHeight'])
    depth = ET.SubElement(size, 'depth')
    depth.text = '3'
  
    # 添加分割信息
    segmented = ET.SubElement(annotation, 'segmented')
    segmented.text = '0'
  
    # 处理每个标注形状
    for shape in data['shapes']:
        obj = ET.SubElement(annotation, 'object')
  
        # 添加对象名称
        name = ET.SubElement(obj, 'name')
        name.text = shape['label']
  
        # 添加姿态信息
        pose = ET.SubElement(obj, 'pose')
        pose.text = 'Unspecified'
  
        # 添加截断信息
        truncated = ET.SubElement(obj, 'truncated')
        truncated.text = '0'
  
        # 添加难度信息
        difficult = ET.SubElement(obj, 'difficult')
        difficult.text = '0'
  
        # 添加边界框
        bndbox = ET.SubElement(obj, 'bndbox')
  
        # 计算边界框坐标
        points = shape['points']
        xmin = ET.SubElement(bndbox, 'xmin')
        xmin.text = str(int(min(p[0] for p in points)))
        ymin = ET.SubElement(bndbox, 'ymin')
        ymin.text = str(int(min(p[1] for p in points)))
        xmax = ET.SubElement(bndbox, 'xmax')
        xmax.text = str(int(max(p[0] for p in points)))
        ymax = ET.SubElement(bndbox, 'ymax')
        ymax.text = str(int(max(p[1] for p in points)))
  
    # 创建ElementTree对象
    tree = ET.ElementTree(annotation)
  
    # 写入XML文件（不包含XML声明）
    xml_filename = os.path.splitext(data['imagePath'])[0] + '.xml'
    xml_path = os.path.join(xml_dir, xml_filename)
  
    # 设置缩进并写入文件
    ET.indent(tree, space="  ")
    tree.write(xml_path, encoding='utf-8', xml_declaration=False)

def convert_all_json(json_dir, xml_dir):
    # 确保输出目录存在
    os.makedirs(xml_dir, exist_ok=True)
  
    # 遍历json目录下所有.json文件
    for filename in os.listdir(json_dir):
        if filename.endswith('.json'):
            json_path = os.path.join(json_dir, filename)
            try:
                json_to_xml(json_path, xml_dir)
                print(f'Converted {filename} successfully')
            except Exception as e:
                print(f'Failed to convert {filename}: {str(e)}')

if __name__ == '__main__':
    # 设置输入输出目录
    input_dir = 'json'
    output_dir = 'xml'
  
    # 执行转换
    convert_all_json(input_dir, output_dir)

以下是具体流程。

数据增强，旋转，翻转，裁剪，噪声，提高模型泛化能力，防止过拟合，添加训练数据量

# zengqiang.py
# 数据增强

import xml.etree.ElementTree as ET
import pickle
import os
from os import getcwd
import numpy as np
from PIL import Image
import shutil
import matplotlib.pyplot as plt

import imgaug as ia
from imgaug import augmenters as iaa


ia.seed(1)


def read_xml_annotation(root, image_id):
    in_file = open(os.path.join(root, image_id))
    tree = ET.parse(in_file)
    root = tree.getroot()
    bndboxlist = []

    for object in root.findall('object'):  # 找到root节点下的所有country节点
        if object is not None:  # 添加这个检查
            bndbox = object.find('bndbox')  # 子节点下节点rank的值

            xmin = int(bndbox.find('xmin').text)
            xmax = int(bndbox.find('xmax').text)
            ymin = int(bndbox.find('ymin').text)
            ymax = int(bndbox.find('ymax').text)
            # print(xmin,ymin,xmax,ymax)
            bndboxlist.append([xmin, ymin, xmax, ymax])
            # print(bndboxlist)

    if not bndboxlist:
        return []

    bndbox = root.find('object').find('bndbox')
    return bndboxlist


# (506.0000, 330.0000, 528.0000, 348.0000) -> (520.4747, 381.5080, 540.5596, 398.6603)
def change_xml_annotation(root, image_id, new_target):
    new_xmin = new_target[0]
    new_ymin = new_target[1]
    new_xmax = new_target[2]
    new_ymax = new_target[3]

    in_file = open(os.path.join(root, str(image_id) + '.xml'))  # 这里root分别由两个意思
    tree = ET.parse(in_file)
    xmlroot = tree.getroot()
    object = xmlroot.find('object')
    bndbox = object.find('bndbox')
    xmin = bndbox.find('xmin')
    xmin.text = str(new_xmin)
    ymin = bndbox.find('ymin')
    ymin.text = str(new_ymin)
    xmax = bndbox.find('xmax')
    xmax.text = str(new_xmax)
    ymax = bndbox.find('ymax')
    ymax.text = str(new_ymax)
    tree.write(os.path.join(root, str("%06d" % (str(id) + '.xml'))))


def change_xml_list_annotation(root, image_id, new_target, saveroot, id,img_name):
    in_file = open(os.path.join(root, str(image_id) + '.xml'))  # 这里root分别由两个意思
    tree = ET.parse(in_file)
    elem = tree.find('filename')
    elem.text = (img_name + str("_%06d" % int(id)) + '.jpg')
    xmlroot = tree.getroot()
    index = 0

    for object in xmlroot.findall('object'):  # 找到root节点下的所有country节点
        bndbox = object.find('bndbox')  # 子节点下节点rank的值

        # xmin = int(bndbox.find('xmin').text)
        # xmax = int(bndbox.find('xmax').text)
        # ymin = int(bndbox.find('ymin').text)
        # ymax = int(bndbox.find('ymax').text)

        new_xmin = new_target[index][0]
        new_ymin = new_target[index][1]
        new_xmax = new_target[index][2]
        new_ymax = new_target[index][3]

        xmin = bndbox.find('xmin')
        xmin.text = str(new_xmin)
        ymin = bndbox.find('ymin')
        ymin.text = str(new_ymin)
        xmax = bndbox.find('xmax')
        xmax.text = str(new_xmax)
        ymax = bndbox.find('ymax')
        ymax.text = str(new_ymax)

        index = index + 1

    tree.write(os.path.join(saveroot, img_name + str("_%06d" % int(id)) + '.xml'))


def mkdir(path):
    # 去除首位空格
    path = path.strip()
    # 去除尾部 \ 符号
    path = path.rstrip("\\")
    # 判断路径是否存在
    # 存在     True
    # 不存在   False
    isExists = os.path.exists(path)
    # 判断结果
    if not isExists:
        # 如果不存在则创建目录
        # 创建目录操作函数
        os.makedirs(path)
        print(path + ' 创建成功')
        return True
    else:
        # 如果目录存在则不创建，并提示目录已存在
        print(path + ' 目录已存在')
        return False


if __name__ == "__main__":

    IMG_DIR = "./images"             ### 原始数据集图像的路径
    XML_DIR = "./Annotations"              ### 原始xml文件的路径

# =============================================================================
#     AUG_XML_DIR = "./Annotations"  # 存储增强后的XML文件夹路径
# =============================================================================
    AUG_XML_DIR = "./val Enhance/xml"              ### 数据增强后的xml文件的保存路径
    try:
        shutil.rmtree(AUG_XML_DIR)
    except FileNotFoundError as e:
        a = 1
    mkdir(AUG_XML_DIR)

# =============================================================================
#     AUG_IMG_DIR = "./JPEGImages"  # 存储增强后的影像文件夹路径
# =============================================================================
    AUG_IMG_DIR = "./val Enhance/images"  ### 数据增强后图片的保存路径
    try:
        shutil.rmtree(AUG_IMG_DIR)
    except FileNotFoundError as e:
        a = 1
    mkdir(AUG_IMG_DIR)

    AUGLOOP = 5  # 每张影像增强的数量

    boxes_img_aug_list = []
    new_bndbox = []
    new_bndbox_list = []

 
    # 影像增强序列配置
    seq = iaa.Sequential([
        # 几何变换增强
        iaa.Flipud(0.5),  # 垂直翻转，50%概率
        iaa.Fliplr(0.5),  # 水平镜像翻转，50%概率
  
        # 颜色空间变换增强
        iaa.Multiply((1.2, 1.5)),  # 亮度调整，1.2-1.5倍随机
        iaa.AddToHueAndSaturation((-20, 20)),  # 色相和饱和度调整，±20随机值
        iaa.LinearContrast((0.8, 1.2)),  # 对比度调整，0.8-1.2倍随机
  
        # 噪声和模糊增强
        iaa.GaussianBlur(sigma=(0, 3.0)),  # 高斯模糊，sigma值0-3随机
        iaa.AdditiveGaussianNoise(scale=(0, 0.05*255)),  # 高斯噪声，强度0-5%随机
  
        # 仿射变换增强
        iaa.Affine(
            translate_px={"x": 15, "y": 15},  # 平移变换，x/y方向各15像素
            scale=(0.8, 0.95),  # 缩放变换，0.8-0.95倍随机
            rotate=(-30, 30)  # 旋转变换，-30到30度随机
        )
    ])


    for root, sub_folders, files in os.walk(XML_DIR):

        for name in files:
            print(name)
            bndbox = read_xml_annotation(XML_DIR, name)
            shutil.copy(os.path.join(XML_DIR, name), AUG_XML_DIR)
            shutil.copy(os.path.join(IMG_DIR, name[:-4] + '.jpg'), AUG_IMG_DIR)

            for epoch in range(AUGLOOP):
                seq_det = seq.to_deterministic()  # 保持坐标和图像同步改变，而不是随机
                # 读取图片
                img = Image.open(os.path.join(IMG_DIR, name[:-4] + '.jpg'))
                # sp = img.size
                img = np.asarray(img)
                # bndbox 坐标增强
                for i in range(len(bndbox)):
                    bbs = ia.BoundingBoxesOnImage([
                        ia.BoundingBox(x1=bndbox[i][0], y1=bndbox[i][1], x2=bndbox[i][2], y2=bndbox[i][3]),
                    ], shape=img.shape)

                    bbs_aug = seq_det.augment_bounding_boxes([bbs])[0]
                    boxes_img_aug_list.append(bbs_aug)

                    # new_bndbox_list:[[x1,y1,x2,y2],...[],[]]
                    n_x1 = int(max(1, min(img.shape[1], bbs_aug.bounding_boxes[0].x1)))
                    n_y1 = int(max(1, min(img.shape[0], bbs_aug.bounding_boxes[0].y1)))
                    n_x2 = int(max(1, min(img.shape[1], bbs_aug.bounding_boxes[0].x2)))
                    n_y2 = int(max(1, min(img.shape[0], bbs_aug.bounding_boxes[0].y2)))
                    if n_x1 == 1 and n_x1 == n_x2:
                        n_x2 += 1
                    if n_y1 == 1 and n_y2 == n_y1:
                        n_y2 += 1
                    if n_x1 >= n_x2 or n_y1 >= n_y2:
                        print('error', name)
                    new_bndbox_list.append([n_x1, n_y1, n_x2, n_y2])
                # 存储变化后的图片
                image_aug = seq_det.augment_images([img])[0]
                path = os.path.join(AUG_IMG_DIR,
                                    name[:-4] + str( "_%06d" % (epoch + 1)) + '.jpg')
                image_auged = bbs.draw_on_image(image_aug, thickness=0)
                Image.fromarray(image_auged).save(path)

                # 存储变化后的XML
                change_xml_list_annotation(XML_DIR, name[:-4], new_bndbox_list, AUG_XML_DIR,
                                           epoch + 1,name[:-4])
                print( name[:-4] + str( "_%06d" % (epoch + 1)) + '.jpg')
                new_bndbox_list = []

标注得到的VOC格式数据集转为coco数据集

# xmlTojson.py
# 用这个将xml转化为json格式可以正常的训练

import xml.etree.ElementTree as ET
import os
import json

coco = dict()
coco['images'] = []
coco['type'] = 'instances'
coco['annotations'] = []
coco['categories'] = []

category_set = dict()
image_set = set()

category_item_id = 0
# image_id = 'ball-'
image_id = 0
id_num = 0
annotation_id = 0


def addCatItem(name):
    global category_item_id
    category_item = dict()
    category_item['supercategory'] = 'none'
    category_item_id += 1
    category_item['id'] = category_item_id
    category_item['name'] = name
    coco['categories'].append(category_item)
    category_set[name] = category_item_id
    return category_item_id


def addImgItem(file_name, size):
    global image_id, id_num
    if file_name is None:
        raise Exception('Could not find filename tag in xml file.')
    if size['width'] is None:
        raise Exception('Could not find width tag in xml file.')
    if size['height'] is None:
        raise Exception('Could not find height tag in xml file.')

    image_item = dict()
    # temp = str(id_num)
    temp = int(id_num)
    # image_item['id'] = image_id + temp
    image_item['id'] = temp
    id_num += 1
    image_item['file_name'] = file_name
    image_item['width'] = size['width']
    image_item['height'] = size['height']
    coco['images'].append(image_item)
    image_set.add(file_name)
    return image_item['id']


def addAnnoItem(object_name, image_id, category_id, bbox):
    global annotation_id
    annotation_item = dict()
    annotation_item['segmentation'] = []
    seg = []
    # bbox[] is x,y,w,h
    # left_top
    seg.append(bbox[0])
    seg.append(bbox[1])
    # left_bottom
    seg.append(bbox[0])
    seg.append(bbox[1] + bbox[3])
    # right_bottom
    seg.append(bbox[0] + bbox[2])
    seg.append(bbox[1] + bbox[3])
    # right_top
    seg.append(bbox[0] + bbox[2])
    seg.append(bbox[1])

    annotation_item['segmentation'].append(seg)

    annotation_item['area'] = bbox[2] * bbox[3]
    annotation_item['iscrowd'] = 0
    annotation_item['ignore'] = 0
    annotation_item['image_id'] = image_id
    annotation_item['bbox'] = bbox
    annotation_item['category_id'] = category_id
    annotation_id += 1
    annotation_item['id'] = annotation_id
    coco['annotations'].append(annotation_item)


def parseXmlFiles(xml_path):
    for f in os.listdir(xml_path):
        if not f.endswith('.xml'):
            continue

        bndbox = dict()
        size = dict()
        current_image_id = None
        current_category_id = None
        file_name = None
        size['width'] = None
        size['height'] = None
        size['depth'] = None

        xml_file = os.path.join(xml_path, f)
        print(xml_file)

        tree = ET.parse(xml_file)
        root = tree.getroot()
        if root.tag != 'annotation':
            raise Exception('pascal voc xml root element should be annotation, rather than {}'.format(root.tag))

        # elem is , , , 
        for elem in root:
            current_parent = elem.tag
            current_sub = None
            object_name = None

            if elem.tag == 'folder':
                continue

            if elem.tag == 'filename':
                file_name = elem.text
                if file_name in category_set:
                    raise Exception('file_name duplicated')

            # add img item only after parse  tag
            elif current_image_id is None and file_name is not None and size['width'] is not None:
                if file_name not in image_set:
                    current_image_id = addImgItem(file_name, size)
                    print('add image with {} and {}'.format(file_name, size))
                else:
                    raise Exception('duplicated image: {}'.format(file_name))
                    # subelem is , , , , 
            for subelem in elem:
                bndbox['xmin'] = None
                bndbox['xmax'] = None
                bndbox['ymin'] = None
                bndbox['ymax'] = None

                current_sub = subelem.tag
                if current_parent == 'object' and subelem.tag == 'name':
                    object_name = subelem.text
                    if object_name not in category_set:
                        current_category_id = addCatItem(object_name)
                    else:
                        current_category_id = category_set[object_name]

                elif current_parent == 'size':
                    if size[subelem.tag] is not None:
                        raise Exception('xml structure broken at size tag.')
                    size[subelem.tag] = int(subelem.text)

                # option is , , , , when subelem is 
                for option in subelem:
                    if current_sub == 'bndbox':
                        if bndbox[option.tag] is not None:
                            raise Exception('xml structure corrupted at bndbox tag.')
                    bndbox[option.tag] = int(option.text)
                    print(f"读取到 {option.tag}: {bndbox[option.tag]}")
  
                if current_sub == 'bndbox':
                    print(f"xmin: {bndbox['xmin']}, ymin: {bndbox['ymin']}, xmax: {bndbox['xmax']}, ymax: {bndbox['ymax']}")

                # only after parse the  tag
                if bndbox['xmin'] is not None:
                    if object_name is None:
                        raise Exception('xml structure broken at bndbox tag')
                    if current_image_id is None:
                        raise Exception('xml structure broken at bndbox tag')
                    if current_category_id is None:
                        raise Exception('xml structure broken at bndbox tag')
                    bbox = []
                    # x
                    bbox.append(bndbox['xmin'])
                    # y
                    bbox.append(bndbox['ymin'])
                    # w
                    width = bndbox['xmax'] - bndbox['xmin']
                    bbox.append(width)
                    # h
                    height = bndbox['ymax'] - bndbox['ymin']
                    bbox.append(height)
  
                    print(f"width: {width}, height: {height}")
                    print(f"文件名: {file_name}, 对象名称: {object_name}, 计算得到的 bbox: {bbox}")
                    print('add annotation with {},{},{},{}'.format(object_name, current_image_id, current_category_id,
                                                                   bbox))
                    addAnnoItem(object_name, current_image_id, current_category_id, bbox)


if __name__ == '__main__':

    xml_path = "./val Enhance/xml"  ## 原始的xml文件路径
    json_file = './nanodet_train_zengqian.json'  ## 转后保存.json文件的路径
    #
    # xml_path = "./Annotations"  ## 原始的xml文件路径
    # json_file = './nanodet_train.json'  ## 转后保存.json文件的路径

    parseXmlFiles(xml_path)
    json.dump(coco, open(json_file, 'w'))

将.xml标签文件转化为一个.json文件，用于coco数据集训练。

查看标注框是否正确，watch.py将展示json中有bbox属性的图片并标注出bbox，以便可视化检查数据标注质量。

# watch.py
# 查看标注框是否正确
import json
import cv2
import os

# 加载 JSON 文件
# nanodet_train.json
# nanodet_train_zengqian.json
with open('nanodet_train_zengqian.json', 'r') as f:
    data = json.load(f)

# 获取图像目录
img_dir = './val Enhance/images'
# img_dir = './images'


# 获取屏幕大小
screen_width = 640
screen_height = 640

# 遍历图像列表
for image in data['images']:
    # 获取图像文件名
    img_file_name = image['file_name']

    # 打开图像文件
    img_path = os.path.join(img_dir, img_file_name)
    img = cv2.imread(img_path)

    # 缩放图像至屏幕大小
    scale = min(screen_width / img.shape[1], screen_height / img.shape[0])
    new_size = (int(img.shape[1] * scale), int(img.shape[0] * scale))
    img = cv2.resize(img, new_size)

    # 获取 annotations 信息
    annotations = [anno for anno in data['annotations'] if anno['image_id'] == image['id']]

    # 绘制方框
    for anno in annotations:
        bbox = anno['bbox']
        x1, y1, w, h = bbox
        cv2.rectangle(img, (x1, y1), (x1 + w, y1 + h), (0, 255, 0), 2)

    # 显示图像
    cv2.imshow(img_file_name, img)

    # 等待按键
    cv2.waitKey(0)

    # 关闭图像窗口
    cv2.destroyAllWindows()

查看数据标注是否正确，以及数据增强后标注是否一同缩放旋转正确对应。

分割训练集和测试集，按比例拆分。

# split_coco.py
import json
import random

def split_coco_data(coco_file, train_ratio=0.8, output_train_file="train.json", output_test_file="test.json"):
    """
    将 COCO 标注文件按照指定的比例分割成训练集和测试集。

    参数:
        coco_file (str): COCO 标注 JSON 文件的路径。
        train_ratio (float): 训练集中图像所占的比例 (默认值: 0.8)。
        output_train_file (str): 保存训练集 COCO JSON 文件的路径 (默认值: "train.json")。
        output_test_file (str): 保存测试集 COCO JSON 文件的路径 (默认值: "test.json")。
    """

    with open(coco_file, 'r') as f:
        coco_data = json.load(f)

    images = coco_data['images']  # 获取所有图像信息
    annotations = coco_data['annotations']  # 获取所有标注信息
    categories = coco_data['categories'] if 'categories' in coco_data else [] # 获取类别信息，如果不存在则设为空列表

    # 随机打乱图像列表，确保分割的随机性
    random.shuffle(images)

    # 计算训练集的大小
    train_size = int(len(images) * train_ratio)

    # 分割图像列表为训练集和测试集
    train_images = images[:train_size]
    test_images = images[train_size:]

    # 获取训练集和测试集图像的 ID 列表
    train_image_ids = [img['id'] for img in train_images]
    test_image_ids = [img['id'] for img in test_images]

    # 根据图像 ID 过滤标注信息，得到训练集和测试集的标注
    train_annotations = [ann for ann in annotations if ann['image_id'] in train_image_ids]
    test_annotations = [ann for ann in annotations if ann['image_id'] in test_image_ids]

    # 创建训练集 COCO 数据集
    train_coco_data = {
        'images': train_images,
        'annotations': train_annotations,
        'categories': categories  # 包含类别信息
    }

    # 创建测试集 COCO 数据集
    test_coco_data = {
        'images': test_images,
        'annotations': test_annotations,
        'categories': categories  # 包含类别信息
    }

    # 将训练集 COCO 数据集保存到 JSON 文件
    with open(output_train_file, 'w') as f:
        json.dump(train_coco_data, f)

    # 将测试集 COCO 数据集保存到 JSON 文件
    with open(output_test_file, 'w') as f:
        json.dump(test_coco_data, f)

    print(f"COCO 数据集分割完成:")
    print(f"  - 训练集: {len(train_images)} 张图像, {len(train_annotations)} 个标注 (保存到 {output_train_file})")
    print(f"  - 测试集: {len(test_images)} 张图像, {len(test_annotations)} 个标注 (保存到 {output_test_file})")


if __name__ == "__main__":
    # 将 'coco_annotations.json' 替换为你的 COCO 标注文件的实际路径
    coco_annotation_file = "nanodet_train.json"

    # 你可以根据需要调整 train_ratio (例如，0.7 表示 70% 用于训练，30% 用于测试)
    split_coco_data(coco_annotation_file, train_ratio=0.8, output_train_file="train.json", output_test_file="test.json")

得到2：8的测试训练集

修改配置文件

模型训练

使用配置文件进行训练

1	python tools/train.py ./config/legacy_v0.x_configs/nanodet-m.yml

待训练完成后模型保存为pth，默认会按照mAP评分保持最佳模型。

可以用刚刚训练的模型测试一下

1	python demo/demo.py video --config ./config/nanodet-m.yml --model ./workspace/nanodet_m/model_best/nanodet_model_best.pth --path ./Video/rc.mp4

恢复中断训练

如果训练意外中断，可以使用PyTorch Lightning 提供的 checkpoint 功能，只需要更改配置文件,将schedule.resume设置为True即可

1
2
3

schedule:
  resume: True  # 或者 False，取决于你是否要恢复训练
  # 其他 schedule 配置

重新启动训练python tools/train.py config\nanodet-plus-m-1.5x_416.yml

PyTorch Lightning 会自动检测 model_last.ckpt 文件，并从上次保存的 checkpoint 恢复训练。

TensorBoard

可视化日志
TensorBoard 日志保存在您在配置文件中设置的位置。save_dir
要可视化 tensorboard 日志，请运行：

1 2	cd tensorboard --logdir ./

观察模型是否收敛：因为仅仅观察损失函数很难判断是否需要停止训练，可观测其性能指标增长趋势逐步调整训练轮次，因为经过数据增强数据集多达5000+，所以此处训练轮次可以适当减少。

主要观察mAP指标继续训练是否还有增长趋势，若还存在上升趋势可追加训练轮次，直到性能指标趋于平稳，则可认为模型以及拟合。

训练350轮

模型导出

pth转onnx

1	python tools/export_onnx.py --cfg_path ./config/nanodet-plus-m-1.5x_416.yml --model_path workspace/nanodet-plus-m-1.5x_416/model_best/nanodet_model_best.pth

onnx转IR

1 2	# 示例：将 ONNX 模型转换为 OpenVINO IR ovc your_model.onnx --output_model openvino_ir

学习率

理论：机器学习——神经网络 | polar-bear～Blog

不同学习率：

过大的学习率：可能导致模型在最优解附近震荡，或者在极端情况下导致模型发散。
过小的学习率：虽然能够保证模型最终收敛，但是会大大降低模型训练的速度。有时，它甚至可能导致模型陷入局部最优解。

观察学习率曲线，此处使用学习率预热（warmup）和学习率衰减（Learning Rate Decay）

warm-up 是指在训练的初期，逐渐增加学习率的过程，以帮助模型更好地收敛到最优解，逐渐增加学习率，而不是直接使用高学习率再衰减的原因是防止在模型初始时高学习率快速降低损失函数至局部最优导致模型后期学习率衰减无法跳出局部最优寻找全局最优（长难句，个人理解）

ratio: 0.0001 # 预热的起始学习率与 lr 的比率在训练的开始会使用低学习率以实现在训练初期更好地适应数据，提高训练的稳定性和性能。

Learning Rate Decay则使模型在后期精细调节,防止震荡,避免过拟合

使用一个简单的线性回归案例，持续高学习率确实可以快速收敛，加快模型收敛速度，突破局部最优寻找全局最优，但是到了模型训练后期，应该缓慢降低学习率，否则高学习率会导致模型陷入局部震荡无法正常收敛，如下图。

（在高学习率下线性回归模型损失值会大幅波动。这表示学习速率过高，模型训练永远不会收敛。）

余弦退火衰减 CosineAnnealingLR:

当越来越接近Loss值的全局最小值时，学习率应该变得更小来使得模型尽可能接近这一点，而余弦退火（Cosine annealing）可以通过余弦函数来降低学习率。余弦函数中随着x的增加余弦值首先缓慢下降，然后加速下降，再次缓慢下降。这种下降模式能和学习率配合，以一种十分有效的计算方式来产生很好的效果。

神经网络在刚开始训练时，并非如同理想的情况一样，只需要确定一个方向即可。模型参数在初始化时，是非常不稳定的，因此在刚开始时需要选用小的学习率。

(图片来自文2)

学习率衰减之余弦退火(CosineAnnealing）-CSDN博客

狗都会用的余弦退火（CosineAnnealingLR）学习率调节算法讲解-CSDN博客

pytorch的余弦退火学习率 - 知乎

Openvino部署

Openvino安装

OpenVINOTM安装分为完整版安装与不完整版(Runtime)安装。

完整版安装会安装所有部件，包括模型优化器和推理部署套件运行工具(Runtime)，目前该方式支持PIP安装方式，因此建议采用PIP安装在虚拟环境中，防止安装出错照成电脑环境出现问题。该安装方式至此Python、C++同时使用，由于安装路径较长，对C++使用不太方便，因此该安装方式最好使用Python编程。

非完整版安装主要安装编译环境(Runtime)，安装比较简单，且一般会安装到根目录下，方便使用，因此如果不使用模型优化且情况下，或者使用C++编译环境的话，建议选用此方式。

openvino推荐使用存档直接安装或者conda安装

ubuntu：Ubuntu 24.04.2 LTS

openvino：2025.1

直接安装

https://docs.openvino.ai/2025/get-started/install-openvino.html?PACKAGE=OPENVINO_BASE&VERSION=v_2025_1_0&OP_SYSTEM=LINUX&DISTRIBUTION=ARCHIVE

前往官网下载对应版本

在/opt下创建文件夹

1	sudo mkdir /opt/intel

解压后移动到/opt/intel

1 2	tar -xf openvino_2025.0.0.tgz sudo mv openvino_toolkit_ubuntu22_2025 /opt/intel/openvino_2025.0.0

可以创建软链接，方便路径。

1 2	cd /opt/intel sudo ln -s openvino_2025.1.0 openvino_2025

安装openvino环境依赖

1 2	cd /opt/intel/openvino_2025.1.0 sudo -E ./install_dependencies/install_openvino_dependencies.sh

配置环境变量

1	vim ~/.bashrc

将脚本路径添加进去，这样每次启动终端都会加载openvino

1 2	source /opt/intel/openvino_2025/setupvars.sh

conda

https://www.anaconda.com/download/success

下载conda安装脚本

一路yes即可

完成安装，刷新一下终端

1	source ~/.bashrc

输入

conda

安装完成后最好升级一下conda

1	conda update -n base -c defaults conda

创建虚拟环境

1	conda create --name py310 python=3.10

进入虚拟环境

1	conda activate py310

将以下命令行添加到 ~/.bashrc ，只需要在终端输入 py310 就直接进入了

1	alias py310='source activate py310'

使用conda安装openvino

1 2	conda update --all conda install -c conda-forge openvino=2025.1.0

openvino安装位置位于

/home/rick/anaconda3/envs/py310/include

/home/rick/anaconda3/envs/py310/lib

测试openvino安装状态

新建main.cpp

#include 
#include 

int main() {
    try {
        // 初始化OpenVINO核心
        ov::Core core;
  
        // 打印OpenVINO版本信息
        std::cout << "OpenVINO version: " << ov::get_openvino_version() << std::endl;
  
        // 获取可用设备列表
        std::vector available_devices = core.get_available_devices();
        std::cout << "Available devices: ";
        for (const auto& device : available_devices) {
            std::cout << device << " ";
        }
        std::cout << std::endl;
  
        return 0;
    } catch (const std::exception& ex) {
        std::cerr << "Exception: " << ex.what() << std::endl;
        return -1;
    }
}

新建CMakeLists.txt

cmake_minimum_required(VERSION 3.5)
project(openvino_test)

set(CMAKE_CXX_STANDARD 17)
set(CMAKE_CXX_STANDARD_REQUIRED ON)

# 设置OpenVINO路径
set(OpenVINO_DIR "/opt/intel/openvino_2025/runtime/include")

# 查找OpenVINO包
find_package(OpenVINO REQUIRED)

# 添加可执行文件
add_executable(openvino_test main.cpp)

# 链接OpenVINO库
target_link_libraries(openvino_test PRIVATE openvino::runtime)

执行：

1	mkdir -p build && cd build && cmake .. && make

ctrl+shift+p或F1打开快捷指令输入

edit configurations (UI)

找到include路径，将openvino路径填入，防止code找不到库，导致include报红。

选择调试配置，使用Cmake

点击cmake插件底部的运行即可使用cmakelist完成编译运行。

安装opencv

直接安装在系统目录

1	sudo apt install libopencv-dev

在cmakelist.txt可以使用

1 2	# 查找依赖包 find_package(OpenCV REQUIRED)

自动搜索到。

安装海康MVS

到下载页面下载：https://www.hikrobotics.com/cn/machinevision/service/download/?module=0

下载机器视觉工业相机客户端MVS V3.0.1 (Linux)

下载的压缩包中含有不同架构的安装包

安装

sudo dpkg -i MVS-3.0.1_x86_64_20241128.deb

安装在/opt/MVS 目录下

运行/opt/MVS/bin/MVS.sh测试是否安装成功。

摄像头频闪

若遇到频闪，则调整曝光时间避开场地光源频率

boost安装

前往官网下载：https://www.boost.org/releases/1.74.0/

下载后解压到任意路径

1	sudo mv ./boost_1_74_0 /opt/boost_1_74_0

执行安装脚本

1	./bootstrap.sh

运行构建命令：./b2

安装库文件：sudo ./b2 install

在Docker中安装Postgresql

2025-04-10T00:40:58.210Z

在Docker中安装Postgresql

有个服务挂在supabase上长期未用，然后发现已经过期，只保留备份文件，遂本地部署。

拉取镜像

1	docker pull postgres

创建本地卷

数据卷可以在容器之间共享和重用，默认会一直存在，即使容器被删除（docker volume inspect pgdata可查看数据卷的本地位置，验证持久数据目录）你也不想数据库和容器一起消失吧

1
2
3

docker volume create pgdata

docker volume inspect pgdata

可以看到输出本地卷信息

root@rick:/home/rick# docker volume inspect pgdata
[
    {
        "CreatedAt": "2025-04-10T08:46:11Z",
        "Driver": "local",
        "Labels": null,
        "Mountpoint": "/var/snap/docker/common/var-lib-docker/volumes/pgdata/_data",
        "Name": "pgdata",
        "Options": null,
        "Scope": "local"
    }
]
root@rick:/home/rick#

启动容器，使用持久数据存储启动 PostgreSQL 容器

启动时，需要将刚上个步骤创建的卷pgdata挂载到容器的/var/snap/docker/common/var-lib-docker/volumes/pgdata/_data目录。

run ：创建并运行一个容器；
–name ：指定容器名称。（容器名称自己设置）
-e POSTGRES_PASSWORD=password，设置环境变量，指定数据库的登录口令为password（password 自己设置）
-p ：指定宿主机和 Docker 容器端口映射，冒号前为宿主机端口号，另一个是容器端口号。（Docker的容器默认情况下只能由本地主机访问，即A主机上的容器不能被B主机访问，所以要做端口映射）（端口号自己设置）
-d postgres：指定使用postgres作为镜像

1	docker run --name postgres -e POSTGRES_PASSWORD=123456 -p 5040:5040 -v pgdata:/var/snap/docker/common/var-lib-docker/volumes/pgdata/_data -d postgres

连接数据库

从容器连接

1	docker exec -it postgres /bin/bash

切换用户

1	su postgres

连接

psql

从主机连接

首先安装客户端sudo apt install postgresql-client

显示容器ip地址docker inspect -f '{{range .NetworkSettings.Networks}}{{.IPAddress}}{{end}}' 容器ID

连接容器：psql -U postgres -h 172.17.0.3

恢复备份文件

1	psql -U postgres -h 172.17.0.3 -f db_cluster-28-10-2024@15-17-45.backup

永久免费LinuxONE云服务器

2025-02-22T22:11:01.284Z

永久免费LinuxONE云服务器

无需信用卡，120天免费续费，注册的时候不要挂梯子，不能安装宝塔不能挂梯，2核4G,

延迟高，但是带宽高

LinuxONE官网：https://linuxone.cloud.marist.edu/#/login

前往官网注册，建议使用QQ邮箱，选择国家：美国，最后申请原因：I want to learn Linux

稍后会发送邮件到邮箱，前往授权后即可登陆。

进入主页，随后创建服务器

名称随意，选择系统，建议Ubuntu

选择设备配置，只有一个可选，创建SSH密钥，用于建立SSH连接，随后创建即可。

等待数分钟，直到服务器状态变为active

使用ssh连接用户名为Linux User对应，默认应该是linux1，ip即为所给ip，端口默认22

连接

使用SSH软件连接

使用刚才创建的私钥连接即可

或者ssh linux1@*. * . * . * -i /win/sshkey

切换root用户

1
2
3

sudo passwd root

su

安装1panel

该服务器因为不能安装宝塔，故可使用1panel

curl -sSL https://resource.fit2cloud.com/1panel/package/quick_start.sh -o quick_start.sh && sudo bash quick_start.sh

开放端口

所有端口

iptables -P INPUT ACCEPT
iptables -P FORWARD ACCEPT
iptables -P OUTPUT ACCEPT
iptables -F

开放后建议安装启用ufw防火墙

1 2	sudo ufw allow 22/tcp sudo ufw enable

Cloudflare Worker自建Docker代理加速

2025-01-22T04:48:31.815Z

Cloudflare Worker自建Docker代理加速

2025/08/12 更新

过去使用的Docker代理已经失效，会出现Missing x-amz-content-sha256错误，现在使用cmliu/CF-Workers-docker.io: 这个项目是一个基于 Cloudflare Workers 的 Docker 镜像代理工具。它能够中转对 Docker 官方镜像仓库的请求，解决一些访问限制和加速访问的问题。

cmliu/CF-Workers-docker.io: 这个项目是一个基于 Cloudflare Workers 的 Docker 镜像代理工具。它能够中转对 Docker 官方镜像仓库的请求，解决一些访问限制和加速访问的问题。

[!WARNING]
根据 Cloudflare 协议中，2.2.1 第 (j) use the Services to provide a virtual private network or other similar proxy services.
使用本服务可能存在被 Cloudflare 封号的潜在风险，请自行斟酌使用风险。
如果你选择了“根据主机名选择对应的上游地址”方式部署，你可能会:
被 Netcraft 扫描到，收到警告邮件
被 Netcraft 同步到 Google Safe Browsing 标记为钓鱼网站
被 Netcraft 投诉到 Cloudflare 标记为钓鱼网站, 无法正常 pull 镜像
收到律师函

打开Cloudflare的Worker复制 _worker.js 代码，保存并部署即可

填写到worker的js文件里面，在标记的地方更改自己的域名，然后部署

并且在worker的设置里面添加自定义的域名

直接访问域名可以直接搜索Docker仓库

使用代理，官方镜像路径前面加域名

1 2	docker pull xxxxx.com/mysql/mysql-server docker pull 自定义域名/+docker包名

Gemini中转API

2025-01-21T19:36:25.936Z

Gemini 转OpenAI API格式

GitHub - PublicAffairs/openai-gemini：Gemini ➜ OpenAI API 代理。无服务器！

选择部署到 Cloudflare

填写帐户 ID和API 令牌

创建令牌

填写帐户 ID和API 令牌

fork到自己的储存库并开启Github action功能

完成

完成后进入到cloudflare 的Worker页面

找到刚刚创建的gemini

在设置中为其添加一个域名

##Gemini API申请

现在中转服务已经部署，接下来是Gemini API申请: https://aistudio.google.com/

列出可用模型

PVE安装Home Assistant

2025-01-07T23:34:05.254Z

PVE安装Home Assistant

接下来默认即可

类型选host

半虚拟化、E1000、直通，感觉半虚拟化和直通差不多

分离并删除硬盘

调整BIOS为UEFI模式，这个是HassOS要求的

下载HA虚拟机文件替代方案 - Home Assistant

下载解压得到qcow2文件传到PVE里面

连接到PVE shell，将文件传到/tmp文件夹下

接下来进入tmp目录,向104（HA）虚拟机导入磁盘

1 2	cd /tmp qm importdisk 104 haos_ova-14.1.qcow2 local-lvm

出现一个未使用的磁盘，双击它添加

在选择-引导顺序里面将硬盘设为第一位

现在可以启动虚拟机了

等待系统最后安装完成，打开网页端，浏览器里面输入这个网址并打开：http://homeassistant.local:8123

Docker安装HomeAssistant

2025-01-06T07:10:34.535Z

Docker安装HomeAssistant

Docker安装不支持附件组件

直接从docker官方直接拉取镜像，可能会遇到网络问题

1	homeassistant/home-assistant

可以从镜像地址下载

1	ghcr.io/home-assistant/home-assistant:stable

Docker安装可兼容多平台，但是此方法安装HA无权访问附加组件

如图，在飞牛OS上安装

docker run -d \
  --name homeassistant \
  --privileged \
  --restart=unless-stopped \
  -e TZ=Asia/Shanghai \
  -v /data/homeassistant:/config \
  --network=host \
  homeassistant/home-assistant

-v /data/homeassistant:/config这一项需要根据自己实际情况修改，即把自己物理机某文件夹挂载到容器内，我是建了个文件夹/data/homeassistant来存放HA的文件

端口8123映射到本地8123

创建一个homeasststant的文件夹，将创建的homeasststant 文件路径，载到容器的 /config 路径

添加环境变量 TZ，将时区设置为 Asia/Shanghai

网络设置成host

访问http://ip:8123即可

在 homeasststant 目录下创建一个名为 custom_components 的文件夹

下载HACS 文件上传并解压到该目录中

1 2	## 下载地址 https://github.com/hacs/integration/releases/tag/2.0.1

重启 Home Assistant.

点击设置-设备与服务

全选，提交

如果点提交之后弹出如下对话框，请直接重启nas设备即可正常往下设置

加载一会，弹窗对话框，点击第一个链接去验证github账号

同意授权即可

Git 使用教程

2024-11-21T03:06:52.058Z

常规操作

开始前我们需要先设置提交的用户信息，包括用户名和邮箱：

1 2	$ git config --global user.name 'name' $ git config --global user.email test@test.com

创建版本库

首先，打开终端或命令行界面，进入要创建版本库的目录下。

接着，使用以下命令初始化一个空的 Git 仓库：

git init

然后，将需要管理的文件添加到暂存区：

git add

你也可以使用以下命令一次性将所有变更添加到暂存区：

git add .

接下来，提交暂存区中的变更到本地仓库，并添加一个描述信息：

1	git commit -m '第一次版本提交'

现在，你已经成功地创建了一个版本库。你可以使用其他 Git 命令来管理它，例如：

git status：查看当前工作区和暂存区的状态。
git log：查看提交记录。
git branch：管理分支。
git remote：管理远程仓库。

远程仓库

如何添加远程仓库

要将本地代码库连接到远程仓库，可以使用以下git命令：

首先，将本地代码库初始化为Git仓库（如果尚未完成）：

git init

添加远程仓库的URL，其中是自定义名称，是远程仓库的URL：

1	git remote add

可以使用以下命令确认远程仓库是否已成功添加：

1	git remote -v

此后，您就可以使用 git push命令将代码推送到远程仓库，或使用 git pull命令从远程仓库拉取代码。

从远程库克隆

要从远程仓库克隆代码到本地，可以使用以下git命令：

git clone

其中是远程仓库的URL。执行此命令后，Git将在当前目录下创建一个新目录，其中包含克隆的代码库副本。如果想指定不同的目录名，可以将目录名作为可选参数添加到命令中：

git clone

创建与合并分支

创建一个新的分支可以使用以下命令：

1	git branch

这将在当前所在的提交上创建一个名为的新分支。

要切换到新创建的分支，可以使用以下命令：

1	git checkout

创建并立即切换到该分支，可以使用以下命令：

1	git checkout -b

合并分支可以使用以下命令：

git merge

这将将分支中的更改合并到当前分支。

推送分支

在 Git 中，推送分支指将本地的分支提交到远程仓库中，使得其他团队成员可以访问和获取该分支的代码。以下是在 Git 中推送分支的一些常用命令：

推送当前分支到远程仓库，并与远程分支关联：

1	git push -u origin

推送当前分支到远程仓库，并与远程分支合并：

1	git push origin

强制推送当前分支到远程仓库：

1	git push -f origin

删除远程分支：

1	git push origin :

或

1	git push --delete origin

在推送分支时，通常会遇到冲突等问题。如果发生冲突，需要先解决冲突，然后再进行推送。

处理冲突

当两个分支上的代码修改了同一部分，并且尝试将这两个分支合并时，就会发生代码冲突。Git提供了以下步骤来解决冲突：

运行 git status 命令查看哪些文件包含冲突。
编辑有冲突的文件，手动解决文件中的冲突。
对编辑后的文件进行 git add，标记为已解决冲突的文件。
使用 git commit 提交更改，Git 会自动生成一个合并提交，其中包含各自分支中的更改。
注意：在解决冲突前，最好先备份当前的代码状态，以免不小心破坏代码库。另外，在处理冲突之前，可以通过运行 git diff 命令来查看冲突的源代码，以便更好地理解要解决的问题。

分支管理策略

在 Git 中，常见的分支管理策略包括以下几个方面：

主分支：主分支通常是最稳定的分支，用于发布生产版本。在 Git 中，主分支通常是 master 分支或者 main 分支。
开发分支：开发分支通常从主分支派生而来，在其上进行新功能或修复错误的开发。在 Git 中，通常使用 develop 分支作为开发分支。
特性分支：特性分支是为了开发单独的功能而创建的分支。这些分支通常从开发分支派生而来，并在实现目标后被合并回开发分支。在 Git 中，通常使用 feature/ 分支命名约定来表示特性分支。
发布分支：发布分支是用于准备发布版本的分支，通常从主分支派生而来。这些分支应该包含与发布相关的所有更改，并且应该经过全面测试和审核后再合并回主分支。在 Git 中，通常使用 release/ 分支命名约定来表示发布分支。
热修复分支：热修复分支通常用于快速修复紧急问题，例如安全漏洞或崩溃。这些分支通常从主分支派生而来，并且只包含必要的更改。在 Git 中，通常使用 hotfix/ 分支命名约定来表示热修复分支。

具体操作

克隆仓库

1 2	git clone git@github.com:TOE-RC/robotmaster-c.git git clone

提交仓库

在本地更改并且保存后，使用这条命令一次性将所有变更添加到暂存区

git add .

提交暂存区中的变更到本地仓库，并添加一个描述信息：

1	git commit -m '第一次版本提交'

提交到远程仓库

git push

处理冲突

在你提交之前假设有其他人提交了新的版本，这时候提交就会出现冲突错误

建议使用VSCode自带的插件

覆盖仓库

本地初始化Git文件夹 git init，绑定远程仓库 git remote add robotmaster-c git@github.com:TOE-RC/robotmaster-c.git，检测仓库是否成功添加 git remote -v。

这里 git pull出现了错误，提示如果你想要拉取并合并特定的分支，你需要指定远程仓库和分支名 git pull remote branch，或者为当前分支设置跟踪信息，之后，你就可以简单地使用 git pull 来拉取最新的代码，而不需要每次都指定远程仓库和分支。

首先先建立本地分支进行第一次提交

1 2	git add . git commit -m "Initial commit"

获取远程仓库的所有分支信息：

git fetch

设置跟踪远程 main 分支

1 2	git branch --set-upstream-to=robotmaster-c/main master git branch --set-upstream-to=仓库名/仓库分支本地分支

此时即可 git pull --allow-unrelated-histories