Frees Ling

What is the meaning of meeting?

Mon, 06 Apr 2026 00:00:00 GMT

If we are destined to part, then what is the meaning of meeting?
The meaning of meeting is
The part of me that you changed
to replace you and stay with me forever.

这句话的意思是：

如果我们注定要分别，那么，相遇的意义又是什么？
相遇的意义就是被你改变的那一部分永远的代替着你留在我身边

YUXUAN

恋爱摘录 1.0

Wed, 25 Mar 2026 00:00:00 GMT

笔者最近处于恋爱之中，深深暗恋某个人
特此摘录

“还是尽早养成一个人去探索世界的习惯比较好，你总是在等，等合适的同伴出现，等朋友有空，等凑在一起的假期，等好天气，但总有一些障碍在拦着，那个最合适的时机永远都没有到来。自己想要的东西直接去拿，自己想过的生活立刻就过，等待的感觉一点也不好。如果不学会现在幸福，将来的你依然不会幸福。

“你想和人一起跑步，并不用等人出现再上跑道。你先跑起来，再坚持下去，志同道合的人就会在此时出现，跟上你的脚步”

在Ubuntu上的另类代码编写

Thu, 12 Mar 2026 00:00:00 GMT

前言

笔者常常苦于虚拟机的延迟，每次在终端输入输出都特别的慢，导致开发效率极低，甚至有时候会崩溃，所以就想到了一个办法，就是在本地使用VScode的Remote SSH插件，在Ubuntu上进行代码编写，这样就可以避免虚拟机的延迟问题了。

方法

在Ubuntu上安装SSH服务

sudo apt update
sudo apt install openssh-server

安装完成后，启动SSH服务

sudo systemctl start ssh
sudo systemctl enable ssh

确认SSH服务已经启动

sudo systemctl status ssh

在本地VScode上安装Remote SSH插件 打开VScode，点击左侧的扩展图标，搜索Remote SSH，安装完成后，点击左下角的绿色图标，选择Remote-SSH: Connect to Host

找到虚拟机 IP，在ubuntu终端输入以下命令获取IP地址

ip a

在VScode中

Ctrl + Shift + P

输入

Remote-SSH: Connect to Host

输入

Remote-SSH: Connect to Host

输入

username@ip

例如

fl@192.168.159.128

后面就可以在windows上使用VScode进行代码编写了，所有的操作都是在Ubuntu上进行的，VScode只是一个远程连接工具，所有的代码都会保存在Ubuntu上，这样就可以避免虚拟机的延迟问题了。

YOLO训练推荐配置

Sun, 08 Mar 2026 00:00:00 GMT

前言

如本文标题所讲，本文档仅供推荐参考

程序

PyCharm

优点： 调用速度快，一键式安装虚拟环境并配置所需要的Python版本 第三方包适配度高，报错信息详细

主要以项目式为主

官网： PyCharm官网 PS：其他的产品也挺好用的（不是打广告，是真的很好用）

GPU

那当然是越新越好啦~

YOLO训练中产生的问题及解决方案

Sun, 08 Mar 2026 00:00:00 GMT

前言

本文配置环境如下

GPU：RTX5060 Laptop
CPU：AMD Ryzen9 8945HX
System：Windows 11

由于系统环境配置极其复杂和相关文档很少很少，而且对于新显卡（RTX 50系列），市面上常规方案并不能很好的适配，所以笔者研究出本文通用，百分百解决问题的方案以供参考

错误原因和错误重现

在YOLO训练中，我们通过使用Ultralytics的YOLO模型来进行训练，以下是测试训练项目架构

yolo/
│
├─ .venv/                # 虚拟环境
├─ dataset/              # 数据集
│   ├─ images/
│   │   ├─ train/
│   │   └─ val/
│   └─ labels/
│       ├─ train/
│       └─ val/
│
├─ models/               # 保存训练后的模型
│
├─ configs/
│   └─ data.yaml      # 数据集配置
│
├─ train.py              # 训练脚本
├─ detect.py             # 推理脚本
├─ .gitignore            
└─ README.md

训练脚本

# ==============================================================
# File: train
# Author: Frees Ling
# Created: 2026/3/8
# Description: 
# Version: 1.0
# ==============================================================
# from ultralytics import YOLO
# import torch
#
# def main():
#     # 检查 GPU
#     print("CUDA available:", torch.cuda.is_available())
#     if torch.cuda.is_available():
#         print("GPU:", torch.cuda.get_device_name(0))
#
#     # 加载预训练模型（推荐从小模型开始）
#     model = YOLO("yolov8n.pt")
#
#     # 开始训练
#     results = model.train(
#         data="data.yaml",      # 数据集配置文件
#         epochs=50,             # 训练轮数
#         imgsz=640,             # 图片尺寸
#         batch=16,              # batch size
#         device=0,              # 使用GPU (0表示第一张显卡)
#         workers=8,             # 数据加载线程
#         project="runs/train",  # 输出目录
#         name="yolo_custom",    # 本次训练名称
#         cache=True,            # 缓存数据集
#         amp=True               # 混合精度训练（GPU会更快）3
#     )
#
# if __name__ == "__main__":
#     main()
from ultralytics import  YOLO

model = YOLO("yolov8n.pt")

results = model.train(
    data = "data.yaml",
    epochs = 10,
    imgsz = 640,
    batch = 16,
    device = 0,
    workers = 12,
    project = "runs/train",
    name = "test",
    cache = True,
    amp = True
    # batch = 24
    # workers = 12
    # imgsz = 640
    # cache = True
    # amp = True
)

按照一般教程的环境安装方法，是下面这样的

pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu124

测试是这么做的

import torch

print(torch.__version__)
print(torch.cuda.is_available())
print(torch.cuda.get_device_name(0))

如果输出是这样的，那么就完成了

True
NVIDIA GeForce RTX 5060 Laptop GPU

但是事实上，我们的输出还真的是这样的，但是这种方法只适用于以往的显卡，并不适用新显卡（50系列），所以训练的时候会报以下错误


C:\Users\lenovo\Desktop\YOLO.venv\Scripts\python.exe C:\Users\lenovo\Desktop\YOLO\train.py
WARNING torchvision==0.20 is incompatible with torch==2.6.
Run 'pip install torchvision==0.21' to fix torchvision or 'pip install -U torch torchvision' to update both.
For a full compatibility table see https://github.com/pytorch/vision#installation
C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\cuda_init_.py:235: UserWarning:
NVIDIA GeForce RTX 5060 Laptop GPU with CUDA capability sm_120 is not compatible with the current PyTorch installation.
The current PyTorch install supports CUDA capabilities sm_50 sm_60 sm_61 sm_70 sm_75 sm_80 sm_86 sm_90.
If you want to use the NVIDIA GeForce RTX 5060 Laptop GPU GPU with PyTorch, please check the instructions at https://pytorch.org/get-started/locally/
warnings.warn(
Ultralytics 8.4.21 Python-3.10.11 torch-2.6.0.dev20241112+cu121 CUDA:0 (NVIDIA GeForce RTX 5060 Laptop GPU, 8151MiB)
engine\trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=16, bgr=0.0, box=7.5, cache=True, cfg=None, classes=None, close_mosaic=10, cls=0.5, compile=False, conf=None, copy_paste=0.0, copy_paste_mode=flip, cos_lr=False, cutmix=0.0, data=data.yaml, degrees=0.0, deterministic=True, device=0, dfl=1.5, dnn=False, dropout=0.0, dynamic=False, embed=None, end2end=None, epochs=10, erasing=0.4, exist_ok=False, fliplr=0.5, flipud=0.0, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.01, lrf=0.01, mask_ratio=4, max_det=300, mixup=0.0, mode=train, model=yolov8n.pt, momentum=0.937, mosaic=1.0, multi_scale=0.0, name=test, nbs=64, nms=False, opset=None, optimize=False, optimizer=auto, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=True, profile=False, project=runs/train, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=C:\Users\lenovo\Desktop\YOLO\runs\detect\runs\train\test, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.5, seed=0, shear=0.0, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.1, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.0, warmup_momentum=0.8, weight_decay=0.0005, workers=12, workspace=None
Overriding model.yaml nc=80 with nc=1
               from  n    params  module                                       arguments                       
0 -1 1 464 ultralytics.nn.modules.conv.Conv [3, 16, 3, 2]
1 -1 1 4672 ultralytics.nn.modules.conv.Conv [16, 32, 3, 2]
2 -1 1 7360 ultralytics.nn.modules.block.C2f [32, 32, 1, True]
3 -1 1 18560 ultralytics.nn.modules.conv.Conv [32, 64, 3, 2]
4 -1 2 49664 ultralytics.nn.modules.block.C2f [64, 64, 2, True]
5 -1 1 73984 ultralytics.nn.modules.conv.Conv [64, 128, 3, 2]
6 -1 2 197632 ultralytics.nn.modules.block.C2f [128, 128, 2, True]
7 -1 1 295424 ultralytics.nn.modules.conv.Conv [128, 256, 3, 2]
8 -1 1 460288 ultralytics.nn.modules.block.C2f [256, 256, 1, True]
9 -1 1 164608 ultralytics.nn.modules.block.SPPF [256, 256, 5]
10 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
11 [-1, 6] 1 0 ultralytics.nn.modules.conv.Concat [1]
12 -1 1 148224 ultralytics.nn.modules.block.C2f [384, 128, 1]
13 -1 1 0 torch.nn.modules.upsampling.Upsample [None, 2, 'nearest']
14 [-1, 4] 1 0 ultralytics.nn.modules.conv.Concat [1]
15 -1 1 37248 ultralytics.nn.modules.block.C2f [192, 64, 1]
16 -1 1 36992 ultralytics.nn.modules.conv.Conv [64, 64, 3, 2]
17 [-1, 12] 1 0 ultralytics.nn.modules.conv.Concat [1]
18 -1 1 123648 ultralytics.nn.modules.block.C2f [192, 128, 1]
19 -1 1 147712 ultralytics.nn.modules.conv.Conv [128, 128, 3, 2]
20 [-1, 9] 1 0 ultralytics.nn.modules.conv.Concat [1]
21 -1 1 493056 ultralytics.nn.modules.block.C2f [384, 256, 1]
22 [15, 18, 21] 1 751507 ultralytics.nn.modules.head.Detect [1, 16, None, [64, 128, 256]]
Model summary: 130 layers, 3,011,043 parameters, 3,011,027 gradients, 8.2 GFLOPs
Transferred 319/355 items from pretrained weights
Traceback (most recent call last):
File "C:\Users\lenovo\Desktop\YOLO\train.py", line 40, in <module>
results = model.train(
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\ultralytics\engine\model.py", line 777, in train
self.trainer.train()
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\ultralytics\engine\trainer.py", line 244, in train
self._do_train()
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\ultralytics\engine\trainer.py", line 366, in _do_train
self._setup_train()
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\ultralytics\engine\trainer.py", line 295, in _setup_train
self.model = self.model.to(self.device)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 1344, in to
return self._apply(convert)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\ultralytics\nn\tasks.py", line 288, in _apply
self = super()._apply(fn)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 904, in _apply
module._apply(fn)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 904, in _apply
module._apply(fn)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 904, in _apply
module._apply(fn)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 931, in _apply
param_applied = fn(param)
File "C:\Users\lenovo\Desktop\YOLO.venv\lib\site-packages\torch\nn\modules\module.py", line 1330, in convert
return t.to(
RuntimeError: CUDA error: no kernel image is available for execution on the device
CUDA kernel errors might be asynchronously reported at some other API call, so the stacktrace below might be incorrect.
For debugging consider passing CUDA_LAUNCH_BLOCKING=1
Compile with TORCH_USE_CUDA_DSA to enable device-side assertions.</module>
进程已结束，退出代码为 1

这个错误报的也很明确，就是显卡太新了，你的CUDA和Pytorch版本不匹配

有意思的是，这个问题的解决方案我居然什么地方都找不到

在苦苦折磨了两天之后，我开始思考，这个问题为什么会无法解决，以至于不论什么AI都无法给到我完美的GPU训练方案，基本上都是让我使用CPU训练

CPU训练，训练一轮在十万大体量数据集里需要至少五个小时，甚至更久，仅仅五十轮迭代就需要十天，所以寻找GPU训练的方案刻不容缓

题外话：明明问题已经很明确了，但是迟迟给不到有效的解决方案，这也说明了当代大众AI的一个弊端，并不具有独立思考能力，但是一想，也蛮恐怖的，如果真的会自己思考了，未来，会变得怎么样呢？

解决方案

严格注意：本解决方案目前完美适用RTX50系列的显卡，并且一定要严格按照教程执行，否则容易引发烧显卡等非常严重的问题

首先根据错误报告理解为什么会报错，在YOLO的训练中，我们不难发现，我们所用的显卡对应安装的CUDA版本和Python安装的PyTorch版本是一一对应的，所以这既是解决办法也是问题的根源所在，我们下载的PyTorch版本和CUDA版本必须一一对应 以下是相关网站链接

PyTorch官网

PyTorch 根据自身电脑安装对应的PyTorch版本

如果找不到对应版本，还可以试一试安装旧版本↓

PyTorch旧版本

例如： 因为我下载的CUDA版本是3.0，所以我安装的PyTorch是13.0，这个不懂可以问AI

CUDA官网

CUDA Toolkit Archive 根据你自身的电脑安装对应的CUDA版本

例如： 我的电脑版本是Windows 11，RTX5060 Laptop，那么我需要下载的CUDA版本是CUDA 3.0

对于50系列的显卡，可能还需要安装一些驱动（更新），比如2026新的爆款游戏《生化危机：安魂曲》就需要更新驱动来支持

NVIDIA驱动下载如果英语不好，当然也有中文网站
NVIDIA驱动下载（中文）

GeGForce 驱动程序 根据自身电脑填表选择需要安装的驱动

这里值得注意的是，在2026年初，出现了新版本驱动更新后烧显卡的情况，这里驱动选择需要非常注意，以下视频含有各个驱动更新的内容以及BUG，可以参考一二再下载所需要的驱动更新

NVIDIA驱动更新视频

后续训练

可以通过以下代码来参考是否完成训练（直接贴上去了，懒得改了，但是已经改成测试版本了）

# ==============================================================
# File: train
# Author: Frees Ling
# Created: 2026/3/8
# Description: Robust training script that falls back to CPU if GPU CUDA
#              kernels are incompatible with the installed PyTorch.
# Version: 1.1
# ==============================================================
from ultralytics import YOLO
import torch
import traceback
import sys


def train():
    # Report CUDA availability and device details
    print("torch.__version__:", torch.__version__)
    cuda_available = torch.cuda.is_available()
    print("CUDA available:", cuda_available)
    if cuda_available:
        try:
            name = torch.cuda.get_device_name(0)
        except Exception:
            name = "<unknown>"
        try:
            cap = torch.cuda.get_device_capability(0)
        except Exception:
            cap = None
        print(f"GPU: {name} compute_capability={cap}")

    model = YOLO("yolov8n.pt")

    # Default training args (attempt GPU first if available)
    train_args = dict(
        data="data.yaml",
        epochs=1,#测试
        imgsz=640,
        batch=16,
        device=0 if cuda_available else 'cpu',
        workers=12,
        project="runs/train",
        name="test",
        cache='disk',
        amp=True if cuda_available else False,
    )

    print("Training args:", train_args)

    try:
        print("Starting training...")
        results = model.train(**train_args)
        print("Training finished successfully.")
        return results
    except Exception as e:
        # Inspect exception to decide whether to retry on CPU
        err_str = str(e)
        print("Training failed with exception:", err_str)

        # Heuristics to detect CUDA / kernel compatibility errors
        cuda_error_indicators = [
            'no kernel image',
            'not compatible',
            'cuda capability',
            'CUDA error',
            'cudaErrorNoKernelImageForDevice',
            'AcceleratorError',
        ]

        if any(ind.lower() in err_str.lower() for ind in cuda_error_indicators):
            print("Detected a CUDA compatibility/kernel error. Retrying on CPU with amp disabled...")
            train_args['device'] = 'cpu'
            train_args['amp'] = False
            # Lower workers on CPU to avoid too many threads (optional)
            if train_args.get('workers', 0) > 4:
                train_args['workers'] = 4
            print("Retry Training args:", train_args)
            try:
                results = model.train(**train_args)
                print("CPU training finished successfully.")
                return results
            except Exception as e2:
                print("Retry on CPU also failed:", e2)
                traceback.print_exc()
                sys.exit(1)
        else:
            # Not a recognized CUDA issue - re-raise with traceback
            traceback.print_exc()
            sys.exit(1)


if __name__ == "__main__":
    train()

如果成功，应该会显示类似输出↓

C:\Users\Lenovo\Desktop\Code\YOLO\.venv\Scripts\python.exe C:\Users\Lenovo\Desktop\Code\YOLO\train.py 
torch.__version__: 2.10.0+cu130
CUDA available: True
GPU: NVIDIA GeForce RTX 5070 Ti compute_capability=(12, 0)
Training args: {'data': 'data.yaml', 'epochs': 50, 'imgsz': 640, 'batch': 16, 'device': 0, 'workers': 12, 'project': 'runs/train', 'name': 'test', 'cache': 'disk', 'amp': True}
Starting training...
Ultralytics 8.4.21  Python-3.10.11 torch-2.10.0+cu130 CUDA:0 (NVIDIA GeForce RTX 5070 Ti, 16303MiB)
engine\trainer: agnostic_nms=False, amp=True, angle=1.0, augment=False, auto_augment=randaugment, batch=16, bgr=0.0, box=7.5, cache=disk, cfg=None, classes=None, close_mosaic=10, cls=0.5, compile=False, conf=None, copy_paste=0.0, copy_paste_mode=flip, cos_lr=False, cutmix=0.0, data=data.yaml, degrees=0.0, deterministic=True, device=0, dfl=1.5, dnn=False, dropout=0.0, dynamic=False, embed=None, end2end=None, epochs=50, erasing=0.4, exist_ok=False, fliplr=0.5, flipud=0.0, format=torchscript, fraction=1.0, freeze=None, half=False, hsv_h=0.015, hsv_s=0.7, hsv_v=0.4, imgsz=640, int8=False, iou=0.7, keras=False, kobj=1.0, line_width=None, lr0=0.01, lrf=0.01, mask_ratio=4, max_det=300, mixup=0.0, mode=train, model=yolov8n.pt, momentum=0.937, mosaic=1.0, multi_scale=0.0, name=test, nbs=64, nms=False, opset=None, optimize=False, optimizer=auto, overlap_mask=True, patience=100, perspective=0.0, plots=True, pose=12.0, pretrained=True, profile=False, project=runs/train, rect=False, resume=False, retina_masks=False, rle=1.0, save=True, save_conf=False, save_crop=False, save_dir=C:\Users\Lenovo\Desktop\Code\YOLO\runs\detect\runs\train\test, save_frames=False, save_json=False, save_period=-1, save_txt=False, scale=0.5, seed=0, shear=0.0, show=False, show_boxes=True, show_conf=True, show_labels=True, simplify=True, single_cls=False, source=None, split=val, stream_buffer=False, task=detect, time=None, tracker=botsort.yaml, translate=0.1, val=True, verbose=True, vid_stride=1, visualize=False, warmup_bias_lr=0.1, warmup_epochs=3.0, warmup_momentum=0.8, weight_decay=0.0005, workers=12, workspace=None
Overriding model.yaml nc=80 with nc=1

                   from  n    params  module                                       arguments                     
  0                  -1  1       464  ultralytics.nn.modules.conv.Conv             [3, 16, 3, 2]                 
  1                  -1  1      4672  ultralytics.nn.modules.conv.Conv             [16, 32, 3, 2]                
  2                  -1  1      7360  ultralytics.nn.modules.block.C2f             [32, 32, 1, True]             
  3                  -1  1     18560  ultralytics.nn.modules.conv.Conv             [32, 64, 3, 2]                
  4                  -1  2     49664  ultralytics.nn.modules.block.C2f             [64, 64, 2, True]             
  5                  -1  1     73984  ultralytics.nn.modules.conv.Conv             [64, 128, 3, 2]               
  6                  -1  2    197632  ultralytics.nn.modules.block.C2f             [128, 128, 2, True]           
  7                  -1  1    295424  ultralytics.nn.modules.conv.Conv             [128, 256, 3, 2]              
  8                  -1  1    460288  ultralytics.nn.modules.block.C2f             [256, 256, 1, True]           
  9                  -1  1    164608  ultralytics.nn.modules.block.SPPF            [256, 256, 5]                 
 10                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 11             [-1, 6]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 12                  -1  1    148224  ultralytics.nn.modules.block.C2f             [384, 128, 1]                 
 13                  -1  1         0  torch.nn.modules.upsampling.Upsample         [None, 2, 'nearest']          
 14             [-1, 4]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 15                  -1  1     37248  ultralytics.nn.modules.block.C2f             [192, 64, 1]                  
 16                  -1  1     36992  ultralytics.nn.modules.conv.Conv             [64, 64, 3, 2]                
 17            [-1, 12]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 18                  -1  1    123648  ultralytics.nn.modules.block.C2f             [192, 128, 1]                 
 19                  -1  1    147712  ultralytics.nn.modules.conv.Conv             [128, 128, 3, 2]              
 20             [-1, 9]  1         0  ultralytics.nn.modules.conv.Concat           [1]                           
 21                  -1  1    493056  ultralytics.nn.modules.block.C2f             [384, 256, 1]                 
 22        [15, 18, 21]  1    751507  ultralytics.nn.modules.head.Detect           [1, 16, None, [64, 128, 256]] 
Model summary: 130 layers, 3,011,043 parameters, 3,011,027 gradients, 8.2 GFLOPs

Transferred 319/355 items from pretrained weights
Freezing layer 'model.22.dfl.conv.weight'
AMP: running Automatic Mixed Precision (AMP) checks...
AMP: checks passed 
train: Fast image access  (ping: 0.10.1 ms, read: 831.1733.7 MB/s, size: 72.1 KB)
train: Scanning C:\Users\Lenovo\Desktop\Code\YOLO\train\labels.cache... 98798 images, 140 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 98798/98798  0.0s
train: Caching images (69.5GB Disk): 100% ━━━━━━━━━━━━ 98798/98798 15.2Kit/s 6.5s
val: Fast image access  (ping: 0.00.0 ms, read: 331.4105.1 MB/s, size: 18.5 KB)
val: Scanning C:\Users\Lenovo\Desktop\Code\YOLO\valid\labels.cache... 2048 images, 3 backgrounds, 0 corrupt: 100% ━━━━━━━━━━━━ 2048/2048  0.0s
val: Caching images (1.5GB Disk): 100% ━━━━━━━━━━━━ 2048/2048 11.3Kit/s 0.2s
optimizer: 'optimizer=auto' found, ignoring 'lr0=0.01' and 'momentum=0.937' and determining best 'optimizer', 'lr0' and 'momentum' automatically... 
optimizer: MuSGD(lr=0.01, momentum=0.9) with parameter groups 57 weight(decay=0.0), 64 weight(decay=0.0005), 63 bias(decay=0.0)
Plotting labels to C:\Users\Lenovo\Desktop\Code\YOLO\runs\detect\runs\train\test\labels.jpg... 
Image sizes 640 train, 640 val
Using 12 dataloader workers
Logging results to C:\Users\Lenovo\Desktop\Code\YOLO\runs\detect\runs\train\test
Starting training for 50 epochs...

      Epoch    GPU_mem   box_loss   cls_loss   dfl_loss  Instances       Size
       1/50      2.07G      1.149     0.9735      1.119         32        640: 100% ━━━━━━━━━━━━ 6175/6175 4.1it/s 25:10
                 Class     Images  Instances      Box(P          R      mAP50  mAP50-95): 100% ━━━━━━━━━━━━ 64/64 6.0it/s 10.6s
                   all       2048       2195      0.971      0.925      0.962      0.656

......

以上，就是关于YOLO训练中新显卡存在的问题解决办法

YOLO新应用-反馈图表解析

Sat, 07 Mar 2026 00:00:00 GMT

前言

本文档仅仅解释基于Yolo v8训练出来的数据集反馈效果图表进行解释

训练数据：12张图片训练，12张图片验证

项目架构

yolo/
│
├─ .venv/                # 虚拟环境
├─ dataset/              # 数据集
│   ├─ images/
│   │   ├─ train/
│   │   └─ val/
│   └─ labels/
│       ├─ train/
│       └─ val/
│
├─ models/               # 保存训练后的模型
│
├─ configs/
│   └─ data.yaml      # 数据集配置
│
├─ train.py              # 训练脚本
├─ detect.py             # 推理脚本
├─ .gitignore            
└─ README.md

解释：在dataset文件夹中，image用于存放训练和验证图片集，labels用于存放训练和验证YOLO数据标注集

集：集合

开始训练

在终端输入以下命令即可开始训练（作用是生成模型文件.pt）

yolo detect train data=configs/data.yaml \
                            model=yolov8n.pt \
                            epochs=50 \
                            imgsz=640 \
                            batch=4 \
                            device=cpu \
                            project=models \
                            name=yolo_train

部分解释： batch：训练内核数量 device：训练方式（GPU/CPU）

后面会生成两个模型文件best.pt和last.pt

反馈图解释

F1 Score（F1 分数）

F1 是 精确率和召回率的折中
- 精度高但是漏掉很多 → F1 不高
- 漏检少但是误报多 → F1 不高
图上通常有一个峰值，告诉你置信度选择多少时 精度和召回率最平衡

解读图表： F1 值整体偏低，说明模型在召回率和精确率之间的平衡不佳。在极低置信度下才能勉强获得一点 F1 值，一旦提高阈值，模型就几乎没有有效预测

Precision（精确率）

精确率 = “我说这是目标的东西，有多少是真的目标？”
图上是精度随置信度变化的曲线

置信度越高（模型越确信这是目标），精度一般越高，但可能会漏掉一些真实目标

解读图表： 当置信度阈值设得足够高时，模型预测的结果都是完全准确的（没有误报）。但这也意味着，为了保证精确率，模型牺牲了大量的召回率

Recall（召回率）

召回率 = “所有真实目标，我找到了多少？”
图上也是随置信度变化

置信度太高会漏掉真实目标 → 召回率下降

PR Curve（Precision-Recall 曲线）

横轴：召回率
纵轴：精确率
曲线越靠右上角，模型性能越好
看这图就知道模型是偏保守（精度高、召回低）还是偏大胆（召回高、精度低）

mAP（Mean Average Precision，平均精度）

评估目标检测模型的综合指标，考虑了精确率和召回率在不同置信度阈值下的表现

mAP50：IoU=0.5 时的平均精度
mAP50-95：IoU 0.5~0.95 的平均精度
模型预测框和真实框重叠得越好，mAP 越高

解读图表： mAP@0.5：0.995，这是一个非常高的数值 这个指标看似完美，但结合其他曲线来看，这很可能是因为数据量极小或类别单一导致的 “假完美”。在实际应用中，这个 mAP 值的参考意义有限

图表解读： 模型在完全不筛选（置信度为 0）时，能检测到 76% 的目标，但只要稍微提高置信度，就几乎检测不到任何目标了。这说明模型对目标的区分能力很弱，大量低置信度的预测其实是噪声

Confusion Matrix（混淆矩阵）

行 = 真实类别
列 = 模型预测类别
对单类任务，主要看 TP（预测对的数量）、FP（误报）、FN（漏报）
越多对角线越深色 → 越好，说明模型预测对的多

图表解读： 数据：所有 12 个真实的 “COCO” 样本，都被正确预测为 “COCO”。没有将背景误判为目标，也没有将目标误判为背景 解读：在这个极小的测试集（12 个样本）上，模型的分类结果是完美的。这也解释了为什么 mAP@0.5 高达 0.995

图表解读： 数据：归一化后，对角线值为 1.00 解读：进一步确认了在这个测试集上，模型的分类准确率是 100%。但这是基于极小样本量得出的结论，不具备泛化能力

图表解读 数据集非常小且单一，这是导致评估指标 “看起来很美” 但实际泛化能力差的根本原因

图表解读： 损失曲线 

train/box_loss, train/cls_loss, train/dfl_loss 都在稳步下降，说明模型在训练集上正在学习 

val/box_loss, val/cls_loss, val/dfl_loss 也在下降，说明模型在验证集上也在收敛，没有明显的过拟合 指标曲线 

precision(B), recall(B), mAP50(B), mAP50-95(B) 都在训练初期迅速提升到很高的水平，然后趋于稳定 解读：训练过程是健康的，模型确实学到了东西。但由于数据集太小，这些指标的提升更多是对训练数据的记忆，而不是对新数据的泛化能力

YOLO新应用-数据标注篇

Sat, 07 Mar 2026 00:00:00 GMT

前言

虽然说在本飞书文档知识库中已经有过相关文档了，理应来说不必再要我多此一举，但是经过笔者亲自试验，觉得难度十分巨大，不论从什么方面来说，都是十分失败的，不应成为教程使用，所以出此教程帮助想要使用YOLO的人跨越门槛，也能十分开心的使用YOLO

本文仅作为参考，有什么奇奇怪怪的问题自己去查

为了方便比较，我将旧版本的数据标注教程也一并放进来YOLO数据标注

本文基于对YOLO模型熟悉的前提下所写，不熟悉也没关系，我也会写的

本文是基础入门，仅教基础的，若我还有时间，我估计也许会写进阶标注

是时候更新一下新技术了！

为什么说YOLO数据标注比较落后，原因有以下几个

LabelImg对于高版本的Python并不支持，而随着YOLO模型的更新换代，所需要的Python版本也会逐渐升高，所需要的数据标注类型多样，不符合趋势
LabelImg十分依赖于PyQt相关模块，不仅配置复杂，也是全英文界面，对于中文入门学习者十分的不友好，学习成本增加
LabelImg已经不更新了，稳定性也在下降，虽然说你可能还可以下到LabelImg（因为还是有很多人去使用这个工具），但是对于未来学习者，会遇到很多无法解决的问题，而究其根本，就是因为版本的不匹配或者解释器的更新带来的各种疑难杂症
LabelImg太容易崩溃了！！！！！！！！！！！！！！！！！！！！！！！！！！/(ㄒoㄒ)/~~

综上，笔者在这里不得不秉弃LabelImg，转向其他数据标注方法

X-AnyLabeling

X-AnyLabeling是我目前找到的替代LabelImg最好的东西

Github仓库地址
https://github.com/CVHub520/X-AnyLabeling

下载地址
Github：https://github.com/CVHub520/X-AnyLabeling/releases/tag/v4.0.0-beta.2

如果没有梯子也是没有关系的，我这里已经贴心的帮你们下载好了
『来自123云盘VIP会员_FL_的分享』X-AnyLabeling 链接：https://www.123865.com/s/l2fqVv-0x2i

如上图所示，为其基本页面

由于一开始是英文界面，只需要在上面这一栏内找到Language选项，选择中文即可

入门使用

第一眼看上去比那个LabelImg高大上多了（bushi

首先准备好以下文件夹

预备数据标注图片文件夹
导出用的文件夹
存放json格式的文件夹

为什么要三个呢，因为我更倾向于分分清楚，这样更直观

第一步：设置输入输出文件夹

首先点击文件，选择打开文件夹，这里选择的是你存放图片的文件夹
其次，还是点击文件，选择更改输出目录，这里选择的是你存放json格式的文件夹，因为你在这个软件每标注一个图片，都会生成对应的json文件，为了避免混淆，笔者建议单独设置

第二步：数据标注

由于是基础入门，本部分仅教用方框标注上一步中我们已经导入了一个文件夹，在导入的时候，就已经自动加载了图片了，如下图我们选择左侧方框工具（或者直接“R”），如下图由于我这里仅作测试为主，所以识别主体是可乐（标签：COCO），直接点击OK，会变成紫色，如下图那么恭喜你，图片的数据标注你完成了

第三步：导出数据

以此类推，我们完成了全部的数据标注，就可以开始导出了

注意：完成全部的数据标注是右下角全部变成勾，并且按下一张没有反应

当我们点击导出的时候，肯定发懵了？！为什么一个YOLO导出会有这么多

其实当YOLO更新的时候，已经不再满足这种拉框的精度，所以会有更多例如点，线，多边形的标注，对应的导出方式和训练方式也不一样，在这里我们选择Hbb即可，会看到如下图在这里我们还需要打开一个文件（classes Files），即类别文件，就是我们数据标注了什么标签，就要在里面写什么标签，如下图

我们标注的标签是 COCO
所以我们txt文本里面写的也是COCO
这个是导出我们想要的数据

选择好后，就如下图，选择一个空文件夹，进行导出

注意：要点击Save with images 不是多此一举，是为了更好的对应

然后一直点Yes，查看我们的导出文件符合我们训练需求，数据标注完成！

本教程到此结束

Python3.10另类常用安装方法

Sat, 07 Mar 2026 00:00:00 GMT

前言

对于一般计算机而言，我们安装python的方式有很多种，但是如果对于虚拟机，或者是开发板这类，网络不一定好用，所以这里，我将介绍另一类常用的安装方法——源码编译安装

注意：本文所用系统Ubuntu20.04.x LTS

编译所需要的工具链

sudo apt update
sudo apt install -y build-essential zlib1g-dev libncurses5-dev libgdbm-dev \
libnss3-dev libssl-dev libreadline-dev libffi-dev libsqlite3-dev wget libbz2-dev

下载Python3.10源码

cd /tmp
wget https://www.python.org/ftp/python/3.10.14/Python-3.10.14.tgz
tar -xvf Python-3.10.14.tgz
cd Python-3.10.14

编译安装

./configure --enable-optimizations
make -j$(nproc)
sudo make altinstall

安装完后验证一下python3.10 --version 这样就已经装好了吗？不并没有。。。。。。。

PIP安装

刚刚编译出来的仅仅是Python本体，还没有任何东西，接下来将进行介绍

python3.10 -m ensurepip --upgrade

#安装完确认一下
python3.10 -m pip --version

#有如下输出证明完成
pip 23.x from ... (python 3.10)

选修：另类高效常用包管理器——UV

在这里声明，笔者一直都十分看好一门后端语言，那就是Rust，我欣赏它干净，快速和安全，所以UV包正是在Rust之下产出的一种非常高效，几乎是秒杀pip级别的存在（pip的慢和冗杂一直被诟病）

第一种安装方法

通过系统级来安装

curl -LsSf https://astral.sh/uv/install.sh | sh

#测试
uv --version

第二种安装方法

通过Python3.10自行安装

python3.10 -m pip install uv

但是安装完之后进行测试，发现并没有uv包，为什么呢？ Ubuntu会把下载的第三方库放在这里~/.local/bin/uv

#先验证一下
ls ~/.local/bin

#输出
fl@fl-virtual-machine:~/桌面/Test/YOLO$ ls ~/.local/bin
pip  pip3  pip3.10  uv  uvx

我们会发现有UV在里面，哎呀，原来没有写进系统里，所以找不到

#加入系统目录
echo 'export PATH=$HOME/.local/bin:$PATH' >> ~/.bashrc
source ~/.bashrc

这样就可以正常使用uv了

项目开发随笔 v1.0

Fri, 06 Mar 2026 00:00:00 GMT

Github仓库
https://github.com/Frees-Ling/Pipeline-inspection

一键安装Vscode Ubuntu

sudo snap install code --classic

安装完Vscode之后一定一定要检查是否有自动保存，特别是针对项目级别工程文件，要不然你只能是对空文件编译

配置Git及密钥

#配置Git用户信息
git config --global user.name "xxx"
git config --global user,email "xx@xx.com"
#配置密钥
ssh-keygen -t rsa -b 4096 -C "xx@xx.com"   #这里会生成密钥
cat ~/.ssh/id_rsa.pub #这里会输出密钥内容，把这个复制粘贴到代码平台的SSH配置里

配置密钥是为了更好的连接和传输代码（SSH）

#全部搞完之后，进行检查
ssh -T git@github.com  #后缀不唯一，这里以GitHub为例

Ubuntu20.04.x LTS 配置C/C++环境

本教程仅供配置C/C++所用，主要用到的工具均为目前常用工具，需要完整的Ubuntu系统（不可以是试用版本）

#主要安装
clang
gdb
g++
gcc

#打开终端
sudo apt update
sudo apt install build-essential

#验证
gcc --version
g++ --version

#如果有版本号出现即为成功，可以进行下一步
sudo apt install gdb

#验证
gdb --version
#验证结果同上

sudo apt install clang
sudo apt install cmake
#这里如果出现无法安装，是因为软件源错误，解决方法如下
sudo cp /etc/apt/sources.list /etc/apt/sources.list.bak #备份
#换源
deb http://archive.ubuntu.com/ubuntu focal main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu focal-updates main restricted universe multiverse
deb http://archive.ubuntu.com/ubuntu focal-security main restricted universe multiverse
#随后执行如下命令
sudo apt update
sudo apt install clang

#验证
clang --version
cmake --version

#备用方案（可选）
sudo apt install build-essential clang gdb cmake ninja-build

ROS系统安装

注意： 本次管道巡检所使用的ROS只能装在Ubuntu20.x上，Ubuntu22.x以上只能安装ROS2

#更新系统
sudo apt update
sudo apt upgrade

#安装工具链
sudo apt install curl gnupg lsb-release

#下载ROS公钥
sudo mkdir -p /usr/share/keyrings
curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.asc \
    | sudo gpg --dearmor -o /usr/share/keyrings/ros-archive-keyring.gpg
    
#添加ROS1 Noetic源
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] \
http://packages.ros.org/ros/ubuntu $(lsb_release -sc) main" \
| sudo tee /etc/apt/sources.list.d/ros-latest.list > /dev/null

#更新软件列表
sudo apt update

#进行安装
sudo apt install ros-noetic-desktop-full #完整版
sudo apt install ros-noetic-ros-base #核心版，仅有ROS

#配置环境变量
echo "source /opt/ros/noetic/setup.bash" >> ~/.bashrc
source ~/.bashrc

#安装依赖
sudo apt install python3-rosdep
sudo rosdep init
rosdep update

#分别开端口测试是否成功
roscore
rosrun turtlesim turtlesim_node

如下图即为成功

管道巡检代码复刻(足球无人机)

如果只是简单的进行catkin make是不行的，会报如下错误

fl@fl-virtual-machine:~/桌面/Pipe/Pipeline-inspection$ catkin_make
Base path: /home/fl/桌面/Pipe/Pipeline-inspection
Source space: /home/fl/桌面/Pipe/Pipeline-inspection/src
Build space: /home/fl/桌面/Pipe/Pipeline-inspection/build
Devel space: /home/fl/桌面/Pipe/Pipeline-inspection/devel
Install space: /home/fl/桌面/Pipe/Pipeline-inspection/install
####
#### Running command: "cmake /home/fl/桌面/Pipe/Pipeline-inspection/src -DCATKIN_DEVEL_PREFIX=/home/fl/桌面/Pipe/Pipeline-inspection/devel -DCMAKE_INSTALL_PREFIX=/home/fl/桌面/Pipe/Pipeline-inspection/install -G Unix Makefiles" in "/home/fl/桌面/Pipe/Pipeline-inspection/build"
####
-- The C compiler identification is GNU 9.4.0
-- The CXX compiler identification is GNU 9.4.0
-- Check for working C compiler: /usr/bin/cc
-- Check for working C compiler: /usr/bin/cc -- works
-- Detecting C compiler ABI info
-- Detecting C compiler ABI info - done
-- Detecting C compile features
-- Detecting C compile features - done
-- Check for working CXX compiler: /usr/bin/c++
-- Check for working CXX compiler: /usr/bin/c++ -- works
-- Detecting CXX compiler ABI info
-- Detecting CXX compiler ABI info - done
-- Detecting CXX compile features
-- Detecting CXX compile features - done
-- Using CATKIN_DEVEL_PREFIX: /home/fl/桌面/Pipe/Pipeline-inspection/devel
-- Using CMAKE_PREFIX_PATH: /opt/ros/noetic
-- This workspace overlays: /opt/ros/noetic
-- Found PythonInterp: /usr/bin/python3 (found suitable version "3.8.10", minimum required is "3") 
-- Using PYTHON_EXECUTABLE: /usr/bin/python3
-- Using Debian Python package layout
-- Found PY_em: /usr/lib/python3/dist-packages/em.py  
-- Using empy: /usr/lib/python3/dist-packages/em.py
-- Using CATKIN_ENABLE_TESTING: ON
-- Call enable_testing()
-- Using CATKIN_TEST_RESULTS_DIR: /home/fl/桌面/Pipe/Pipeline-inspection/build/test_results
-- Forcing gtest/gmock from source, though one was otherwise available.
-- Found gtest sources under '/usr/src/googletest': gtests will be built
-- Found gmock sources under '/usr/src/googletest': gmock will be built
-- Found PythonInterp: /usr/bin/python3 (found version "3.8.10") 
-- Found Threads: TRUE  
-- Using Python nosetests: /usr/bin/nosetests3
-- catkin 0.8.12
-- BUILD_SHARED_LIBS is on
-- BUILD_SHARED_LIBS is on
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- ~~  traversing 1 packages in topological order:
-- ~~  - rectangle
-- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
-- +++ processing catkin package: 'rectangle'
-- ==> add_subdirectory(rectangle)
-- Could NOT find mavros (missing: mavros_DIR)
-- Could not find the required component 'mavros'. The following CMake error indicates that you either need to install the package with the same name or change your environment so that it can be found.
CMake Error at /opt/ros/noetic/share/catkin/cmake/catkinConfig.cmake:83 (find_package):
  Could not find a package configuration file provided by "mavros" with any
  of the following names:

    mavrosConfig.cmake
    mavros-config.cmake

  Add the installation prefix of "mavros" to CMAKE_PREFIX_PATH or set
  "mavros_DIR" to a directory containing one of the above files.  If "mavros"
  provides a separate development package or SDK, be sure it has been
  installed.
Call Stack (most recent call first):
  rectangle/CMakeLists.txt:10 (find_package)


-- Configuring incomplete, errors occurred!
See also "/home/fl/桌面/Pipe/Pipeline-inspection/build/CMakeFiles/CMakeOutput.log".
See also "/home/fl/桌面/Pipe/Pipeline-inspection/build/CMakeFiles/CMakeError.log".
Invoking "cmake" failed

那么错误报告很明显，缺失mavros这个包，我们需要进行安装如下是解决方案

# 更新软件源列表
sudo apt update

# 修复可能的依赖损坏
sudo apt --fix-missing install

# 安装 mavros 核心包
sudo apt install ros-noetic-mavros ros-noetic-mavros-extras

# 安装 mavros 的地理数据（用于 GPS 等功能，必须装）
wget https://raw.githubusercontent.com/mavlink/mavros/master/mavros/scripts/install_geographiclib_datasets.sh
chmod +x install_geographiclib_datasets.sh
sudo ./install_geographiclib_datasets.sh

# 删除临时脚本（可选）
rm install_geographiclib_datasets.sh

#如果报如下错误
fl@fl-virtual-machine:~/桌面/Pipe/Pipeline-inspection$ wget https://raw.githubusercontent.com/mavlink/mavros/master/mavros/scripts/install_geographiclib_datasets.sh
--2026-03-06 14:49:11--  https://raw.githubusercontent.com/mavlink/mavros/master/mavros/scripts/install_geographiclib_datasets.sh
正在解析主机 raw.githubusercontent.com (raw.githubusercontent.com)... 185.199.110.133, 185.199.109.133, 185.199.108.133, ...
正在连接 raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... 已连接。
已发出 HTTP 请求，正在等待回应... 读取文件头错误 (连接被对方重设)。
重试中。

--2026-03-06 14:49:31--  (尝试次数： 2)  https://raw.githubusercontent.com/mavlink/mavros/master/mavros/scripts/install_geographiclib_datasets.sh
正在连接 raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443... 已连接。
已发出 HTTP 请求，正在等待回应... 读取文件头错误 (连接被对方重设)。
重试中。

--2026-03-06 14:49:53--  (尝试次数： 3)  https://raw.githubusercontent.com/mavlink/mavros/master/mavros/scripts/install_geographiclib_datasets.sh
正在连接 raw.githubusercontent.com (raw.githubusercontent.com)|185.199.110.133|:443...

#那么就是网络问题了

#如果下载失败，可进行如下操作
sudo apt install geographiclib-tools
sudo geographiclib-get-geoids egm96-15

#验证
# 查找 mavros 包的位置
rospack find mavros

# 预期输出（类似）：
# /opt/ros/noetic/share/mavros

那么解决了包缺失，我们可以很顺利地进行构建，如下为成功构建

fl@fl-virtual-machine:~/桌面/Pipe/Pipeline-inspection$ catkin_make
Base path: /home/fl/桌面/Pipe/Pipeline-inspection
Source space: /home/fl/桌面/Pipe/Pipeline-inspection/src
Build space: /home/fl/桌面/Pipe/Pipeline-inspection/build
Devel space: /home/fl/桌面/Pipe/Pipeline-inspection/devel
Install space: /home/fl/桌面/Pipe/Pipeline-inspection/install
####
#### Running command: "make cmake_check_build_system" in "/home/fl/桌面/Pipe/Pipeline-inspection/build"
####
####
#### Running command: "make -j8 -l8" in "/home/fl/桌面/Pipe/Pipeline-inspection/build"
####
Scanning dependencies of target mytest
Scanning dependencies of target detection
Scanning dependencies of target yaw_printer
Scanning dependencies of target cross_rectangle
[ 11%] Building CXX object rectangle/CMakeFiles/yaw_printer.dir/src/yaw_printer.cpp.o
[ 22%] Building CXX object rectangle/CMakeFiles/detection.dir/src/threshold_binary.cpp.o
[ 33%] Building CXX object rectangle/CMakeFiles/mytest.dir/src/test2.cpp.o
[ 44%] Building CXX object rectangle/CMakeFiles/cross_rectangle.dir/src/cross_rectangle.cpp.o
[ 55%] Building CXX object rectangle/CMakeFiles/cross_rectangle.dir/src/PID_controller.cpp.o
[100%] Linking CXX executable /home/fl/桌面/Pipe/Pipeline-inspection/devel/lib/rectangle/yaw_printer
[100%] Linking CXX executable /home/fl/桌面/Pipe/Pipeline-inspection/devel/lib/rectangle/cross_rectangle
[100%] Linking CXX executable /home/fl/桌面/Pipe/Pipeline-inspection/devel/lib/rectangle/mytest
[100%] Linking CXX executable /home/fl/桌面/Pipe/Pipeline-inspection/devel/lib/rectangle/detection
[100%] Built target yaw_printer
[100%] Built target mytest
[100%] Built target detection
[100%] Built target cross_rectangle

第三方库安装

Eigen（线性代数库）

sudo apt update
sudo apt install libeigen3-dev

安装完成后，头文件在 /usr/include/eigen3

OpenCV2

sudo apt install libopencv-dev=2.4.9+dfsg-1

注意：Ubuntu 20.04 默认可能没有旧版 OpenCV2，需要自己编译，或者干脆用 OpenCV4，API 兼容性大部分没问题

OpenCV2 编译版

sudo apt install build-essential cmake git libgtk2.0-dev pkg-config libavcodec-dev libavformat-dev libswscale-dev
git clone https://github.com/opencv/opencv.git
cd opencv
git checkout 2.4
mkdir build && cd build
cmake ..
make -j$(nproc)
sudo make install

安装完成后，头文件在 /usr/include/opencv 和 /usr/include/opencv2

国内

git clone https://gitee.com/OpenCVChina/opencv.git
cd opencv
git checkout 2.4
mkdir build
cd build
cmake ..
make -j$(nproc)
sudo make install```

Unitree Go2 基础开发演示及配置

Fri, 09 Jan 2026 00:00:00 GMT

Unitree Go2 基础开发演示及其配置

Author: Frees Ling

本文介绍了如何进行Unitree Go2 EDU型号进行二次开发的基础演示以及配置方法 仅限实现Hello world DEMO程序测试运行

注意：本文档仅限于在Unitree Go2 EDU上机载主机进行二次开发使用，如有其他方法，请参考官方技术文档

一、准备工作

硬件准备
- Unitree Go2 EDU机器人
- 电脑（Ubuntu 20及以上）
- 一根网线连接机器人和电脑
软件准备
- 安装Ubuntu 20及以上版本
- VS code编辑器

二、简要介绍

如图，为Unitree Go2 的架构，这里我们可以通过ROS系统进行二次开发，数据通信到DDS数据中间件，再通过DDS传输到机器人上进行控制

OTA：Over The Air 空中下载技术，可以通过无线网络对机器人进行远程升级 BLE：Bluetooth Low Energy 低功耗蓝牙技术 UWB：Ultra Wide Band 超宽带技术，主要用于定位 GST SDK:图像模块传输SDK 基础服务：机器人底层控制服务和获取基础信息

部分参考文档
ROS2官网：https://www.ros.org
宇树文档中心：https://support.unitree.com/home/zh/developer
ROS2理论与实践：https://www.bilibili.com/video/BV1VB4y137ys

三、具体操作步骤

1. 使用网线连接机器人和电脑

将网线一端连接到机器人上的以太网口，另一端连接到电脑的以太网口，如图

2. 配置电脑网络

打开电脑的网络设置，找到以太网口的网络配置

IP地址为192.168.123.xxx；子网掩码为255.255.255.0

图示仅供参考，具体以实际操作界面为准

3. 下载克隆官方ROS2，SDK

在本地新建一个文件夹用于存储克隆代码，打开终端，进入该文件夹，执行以下命令

#Ubuntu 20
cd xxx/your_folder_path
sudo apt-get update
sudo apt-get install -y cmake g++ build-essential libyaml-app-dev libeigen3-dev libbost-all-dev libspdbg-dev libfmt-dev
#如果权限不足，可以使用sudo -i提权

克隆ROS2代码

#克隆默认使用SSH进行克隆
git clone git@github.com:unitreerobotics/unitree-ros2.git

克隆SDK代码

git clone git@github.com:unitreerobotics/unitree_sdk.git

官方教程

我没有构建编译成功估计是因为机器狗算力板上面的安全模块没有驱动成功，当然也可以自行参考官方进行编译首先克隆仓库至本地
git clone git@github.com:unitreerobotics/unitree-ros2.git
mkdir build
cd build
cmake ..
make
然后直接进入syslonedds_ws文件进行编译
cd cyclonedds_ws
source install/setup.bash
ros2 run go2_helloworld hello

4.使用VS code SSH远程连接机器人

如上图，使用SSH远程连接机器人

username: unitree@192.168.123.18
password: 123

连接完成后，会显示ros:foxy(1) noetic(2) ?，此处请按照ubuntu系统版本选择

Ubuntu 20请选择1，Ubuntu 22请选择2

5.运行Hello world DEMO程序

选择完成后，我们进入系统环境目录，进行Unitree Go2的ROS2环境进行构建 此处我们将上面已有的ROS2和SDK代码拖入cyclonedds_ws/src目录下

注意：这里的helloworld文件夹可以在GitHub仓库中自行下载 https://github.com/fcs-z/unitree_go2_ws/tree/main/src/helloworld

注意⚠️：本文档只按照当前系统环境进行操作

cd cyclonedds_ws
source install/setup.bash

运行完成后，我们可以通过运行`ROS2`来检查自己是否真的启动了ROS2环境如果上面完成后，那么恭喜你，已经解决了99%的问题，还剩下最后1%的问题

编译程序

注意⚠️： 我们所有编译好的程序包都需要放在cyclonedds_ws/src目录下

此时我们进入cyclonedds_ws目录下进行编译

colcon build

构建编译时间需要等待，等待其完成后请运行

ros2 run go2_helloworld hello

这里我们提供了两种方法调用，你还可以使用python构建的模块包

ros2 run go2_helloworld_py hello

注意⚠️：如果构建失败请尝试以下方法 在同目录下，请运行rm -rf build install log 然后再重新尝试编译程序

恭喜你，完成了Unitree Go2二次开发入门

Simple-AI

Fri, 24 Oct 2025 00:00:00 GMT

构建一个简单的AI模型入门指南

引言

由于所学知识的增加，以及对AI的好奇，我决定尝试构建一个简单的AI模型作为我AI 学习的入门项目

本文将依据网上资料，ChatGPT的帮助，以及个人经验，介绍如何构建一个基础的AI模型。具体数学原理等到后续有时间再补充。

关于AI模型

AI的本质是什么？如何去定义一个AI？

在我看来，AI的本质实际上是让机器通过数据和算法“学习”并发现规律，在此基础上进行预测或生成内容。

组成要素

数据（Data）：原材料，训练/验证/测试集
模型/表示（Model/Representation）：用数学或结构表示规律
学习算法（Learning Algorithm）：如何从数据中调整模型参数（eg：梯度）
目标/损失（Objective/Loss）：定义标准（准确率）
评估与泛化（Evaluation/Generalization）：测试模型在新数据上的表现
部署与反馈（Deployment/Feedback）：实际应用和持续改进（线上A/B，持续学习）

判断一个AI

可以从经验（数据）改善自身（具有学习能力）
能推断/预测新数据（不是训练数据）
能在某类任务上可以自动化决策
自适应……

构建一个简单的AI模型（以二分类为例）

实现步骤（理论）

明确任务
收集或构造数据：CSV,Excel,数据库
特征工程：清洗数据，缺失值处理，标准化，one-hot编码
选择模型与训练：eg：逻辑回归，决策树，神经网络
评估模型：混淆矩阵，ROC，交叉验证，F1-score
部署或保存：保存模型，API

一些定义的解释
清洗数据：把原始数据转为适合建模的形式（去噪、统一格式、移除重复、修正错误等）
缺失值处理：均值填充，删除行/列
标准化：把特征缩放到可比的数值范围，常用于基于距离或梯度的模型
one-hot编码：把类别特征转换为二进制向量，每个类别对应一列（互斥）
混淆矩阵：二分类或多分类预测结果的计数表（TP/FP/FN/TN）
ROC曲线：ROC 曲线以假阳性率（FPR）为横轴、真正率（TPR）为纵轴
交叉验证：把训练集分成多个折（folds），轮流作为验证集以评估模型稳定性
F1-score：精确率（Precision）和召回率（Recall）的调和平均：F1 = 2 * (P * R) / (P + R)

用scikit-learn写一个简单的二分类AI模型

环境准备

建议环境Python 3.8+

建立一个虚拟环境（可选）

# windows [powershell]
python -m venv venv
.\venv\Scripts\Activate.ps1

# macOS/Linux
python3 -m venv venv
source venv/bin/activate

安装依赖

pip install numpy pandas scikit-learn joblib flask

joblib: 保存/加载模型
flask: 做成HTTP任务

训练脚本

将下列代码保存为train_model.py

# ==============================================================
# File: TrainModel.py
# Author: Frees Ling
# Created: 2025-10-24
# Description: A script to train a simple logistic regression model
#              to predict student pass/fail based on hours studied.
# Version: 1.0
# ==============================================================
import argparse
import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
import joblib
import os

from tensorflow.python.data.util.structure import NoneTensor


def load_data(csv_path):
    """
    CSV format: hours_studied, passed
    passed: 0 or 1
    """
    df = pd.read_csv(csv_path)
    # check
    assert 'hours_studied' in df.columns and 'passed' in df.columns, "CSV must have hours_studied and passed columns"
    X = df[['hours_studied']].values
    Y = df['passed'].values
    return X, Y

def train_save(csv_path, model_out='model.joblib', scaler_out='scaler.joblib', test_size=0.2, random_state=42):
    X, Y = load_data(csv_path)
    X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=test_size, random_state=random_state, stratify=Y if len(np.unique(Y)) > 1 else None)

    scaler = StandardScaler()
    X_train_s = scaler.fit_transform(X_train)
    X_test_s = scaler.transform(X_test)

    model = LogisticRegression(max_iter=200)
    model.fit(X_train_s, Y_train)

    Y_pred = model.predict(X_test_s)
    print("Accuracy:", accuracy_score(Y_test, Y_pred))
    print("Confusion Matrix:\n", confusion_matrix(Y_test, Y_pred))
    print("Classification Report:\n", classification_report(Y_test, Y_pred))

    joblib.dump(model, model_out)
    joblib.dump(scaler, scaler_out)
    print(f"Saved model -> {model_out}, scaler -> {scaler_out}")

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Simple AI First test')
    parser.add_argument('--csv', type=str, default="data.csv", help='Path to the CSV data file')
    parser.add_argument('--model_out', type=str, default="model.joblib", help='Path to save the trained model')
    parser.add_argument('--scaler_out', type=str, default="scaler.joblib", help='Path to save the scaler')
    parser.add_argument('--test_size', type=float, default=0.2, help='Test size')
    parser.add_argument('--random_state', type=int, default=42, help='Random state for reproducibility')
    args = parser.parse_args()

    if not os.path.exists(args.csv):
        #If no csv file, create a sample one
        sample = pd.DataFrame({
            'hours_studied': [1, 2, 3, 4, 5, 6, 7, 8, 9, 10],
            'passed': [0, 0, 0, 0, 1, 1, 1, 1, 1, 1]
        })
        sample.to_csv(args.csv, index=False)
        print(f"Sample data created at {args.csv}. Edit it to add your data, then re-run training.")
    train_save(args.csv, args.model_out, args.scaler_out, args.test_size, args.random_state)

运行训练脚本

使用示例数据自动生成并训练

python train_model.py
# 注意要在同一文件夹下运行

或者使用自己的CSV数据

python train_model.py --csv your_data.csv --model_out my_model.joblib --scaler_out my_scaler.joblib

注意：

CSV必须有hours_studied和passed两列（你可以拓展特证名，然后在load_data修改）

在里面我是用stratify = Y来保证训练集和测试集的类别分布一致

运行示例图如下 如果没有csv文件，会自动生成一个示例文件data.csv，你可以编辑它来添加自己的数据，然后重新运行训练脚本。

加载模型并进行预测（命令行）

将下列代码保存为predict_cli.py

# ==============================================================
# File: predict_cli
# Author: Frees Ling
# Created: 2025/10/24
# Description: Cli tool to predict student pass/fail using a trained model
# Version: 1.0
# ==============================================================
import argparse
import joblib
import numpy as np

def predict(hours, model_path='model.joblib', scaler_path='scaler.joblib'):
    model = joblib.load(model_path)
    scaler = joblib.load(scaler_path)
    X = np.array(hours).reshape(-1,1)
    X_s = scaler.transform(X)
    preds = model.predict(X_s)
    probs = model.predict_proba(X_s)[:,1]
    return preds, probs

if __name__ == "__main__":
    parser = argparse.ArgumentParser(description='Predict student pass/fail based on hours studied')
    parser.add_argument('--hours', type=float, nargs='+', help='List of hours studied')
    parser.add_argument('--model_path', type=str, default='model.joblib', help='Path to the trained model')
    parser.add_argument('--scaler_path', type=str, default='scaler.joblib', help='Path to the scaler')
    args = parser.parse_args()
    preds, probs = predict(args.hours, args.model_path, args.scaler_path)
    for h, p, prob in zip(args.hours, preds, probs):
        print(f"Hours Studied: {h} => predict={int(p)}, prob_of_pass={prob:.3f}")

运行实例：

python predict_cli.py --hours 2 4 6 8 10
# 输出示例
# Hours Studied: 2.0 => predict=0, prob_of_pass=0.123
# Hours Studied: 4.0 => predict=0, prob_of_pass=0.345
# Hours Studied: 6.0 => predict=1, prob_of_pass=0.678
# Hours Studied: 8.0 => predict=1, prob_of_pass=0.890
# Hours Studied: 10.0 => predict=1, prob_of_pass=0.950

把模型做成HTTP服务（Flask）

将下列代码保存为app.py

# ==============================================================
# File: model_html
# Author: Frees Ling
# Created: 2025/10/24
# Description: curl command to get model summary in HTML format
# Version: 1.0
# ==============================================================
# app.py
from flask import Flask, request, jsonify
import joblib
import numpy as np

app = Flask(__name__)
MODEL_PATH = "model.joblib"
SCALER_PATH = "scaler.joblib"

model = joblib.load(MODEL_PATH)
scaler = joblib.load(SCALER_PATH)

@app.route("/predict", methods=["POST"])
def predict():
    """
    receipt JSON: {"hours":[2.2 4.5 6.0]}
    return      : [{"hours":2.2,"predict":0,"prob":0.123},...]
    """
    data = request.get_json()
    if not data or 'hours' not in data:
        return jsonify({"error": "please send JSON with 'hours' list"}), 400
    hours = np.array(data['hours']).reshape(-1, 1)
    Xs = scaler.transform(hours)
    preds = model.predict(Xs)
    probs = model.predict_proba(Xs)[:, 1]
    out = []
    for h, p, prob in zip(hours, preds, probs):
        out.append({"hours": float(h[0]), "predict": int(p), "prob": float(prob)})
    return jsonify(out)

if __name__ == "__main__":
    app.run(host="0.0.0.0", port=8080, debug=True)

运行Flask服务：

python app.py

测试（要另开一个终端）

Invoke-WebRequest -Uri "http://127.0.0.1:8080/predict" `
  -Method POST `
  -Body '{"hours":[2.2,4.63,255]}' `
  -ContentType "application/json"

这里我让我的朋友在远程测试了一下这个API服务，以下是他发回来的截图换一个IP地址试试呢这就很有意思了，为什么远程无法调用呢？
经过一番排查，发现是因为防火墙的问题，默认情况下，Flask只允许本地访问，无法接入公网，所以远程无法访问。
当然也不是不无解决方法，我们可以通过以下几种方式解决这个问题：

关闭防火墙（不推荐，安全风险）
配置防火墙规则，允许8080端口的入站流量
使用反向代理（如Nginx）将请求转发到Flask应用
使用云服务（如Heroku, AWS）部署Flask应用
使用ngrok等工具创建公网隧道

后记：AI学习之路任重而道远，本文只是一个入门级别的尝试，希望能帮助到和我一样的AI初学者。未来我会继续深入学习AI相关知识，并分享更多有趣的项目和经验。感谢阅读！

Github入门

Wed, 24 Sep 2025 00:00:00 GMT

Github入门

什么是Github

Github是一个基于Git的代码托管平台，允许开发者存储、管理和协作开发代码。它提供了版本控制、分支管理、问题跟踪等功能，是开源项目和团队协作的理想选择。

注册Github账号

首先进入Github官网，点击此可以进入，可以看到如下图的界面

点击右上角的“Sign up”按钮进入注册界面

填写用户名、邮箱和密码，点击“Create account”按钮，然后按照教程一步一步创建账户，完成注册。

当进入此界面时，恭喜你，注册成功了。此时点击右上角的头像，再点击Profile，就可以进入你的个人主页了。

配置个人资料

配置个人资料可不是仅仅填写头像下面那个简介而已，作为优秀的“码农”，我们还需有自己的个性化介绍

点击repositories，查看自己的仓库
点击NEW，创建新的仓库
这个仓库的名称需要与你注册账户时的账单名称一致，比如我叫Frees-Ling，那么我创建的仓库名称也必须是Frees-Ling
完成后点击创建，如下图

注意：这里我已经配置好了我的个人简介，所以你看到的界面会有所不同

将你的个人简介写在README.md文件中，点击Commit new file，完成创建,你就可以在你的主页看到你的个人介绍了！

恭喜你！Github入门了

GitHub基本用法&团队协作

一、项目初始化与克隆

本地初始化（可选）

git init

从远程仓库克隆

git clone https://github.com/FURS-community/furs-community.github.io.git
# 仅作示例！！！！！请勿克隆此仓库

二、日常开发流程（本地操作）

新建功能分支

git checkout -b main

查看状态

git status

添加文件到暂存区

git add filename
git add .

注意：空文件夹并不会被git跟踪

提交变更

 git commit -m "feat: describe"

推送到远程

git push origin main

三、协作开发，自动合并

切换主分支并拉取到最新代码

git checkout main
git pull origin main

合并到主分支

git merge main

注意：如果出现冲突

- 使用VC code解决（其他也可以）
- 冲突解决后

git add .
git commit

推送合并后的主分支

git push origin main

四、清理工作

删除合并后的功能分支

#本地
git branch -d feat/describe
#远程
git push origin --delete main

五、补充

查看分支

#本地
git branch
#远程
git branch -r

删除文件跟踪（保留本地）

git rm --cached filename

后续提交方法（上述初始工作已完成）

git add .
git commit -m "deacribe"
git push origin main

注意：每次提交之后在群里说明

使用 SSH 连接 GitHub 仓库

本文档总结了从本地配置到远程连接 GitHub 仓库的完整 SSH 方法。

先导：GitHub中创建自己的SSH密钥

点击右上角头像 → Settings → SSH and GPG keys → New SSH key
填写 Title，粘贴公钥内容，点击 Add SSH key 保存
（公钥内容可通过 cat ~/.ssh/id_rsa.pub 查看）

1. 检查是否已有 SSH Key

ls -al ~/.ssh

如果已经存在 id_rsa 和 id_rsa.pub，则可以跳过生成步骤。

2. 生成新的 SSH Key

ssh-keygen -t rsa -b 4096 -C "your_email@example.com"

按提示输入保存路径（默认即可：~/.ssh/id_rsa）。
可以设置密码，也可以直接回车跳过。

3. 启动 SSH Agent 并添加密钥

eval "$(ssh-agent -s)"
ssh-add ~/.ssh/id_rsa

4. 将公钥添加到 GitHub

cat ~/.ssh/id_rsa.pub

复制输出内容，进入 GitHub → Settings → SSH and GPG keys → New SSH key，粘贴并保存。

5. 测试连接

ssh -T git@github.com

若提示：

Hi username! You've successfully authenticated, but GitHub does not provide shell access.

说明配置成功。

6. 配置远程仓库地址

git init
git remote add origin git@github.com:username/repo.git
git remote -v

7. 修改默认 SSH 端口（可选）

由于本地使用默认的连接端口极其容易发生断开连接，GitHub同时也针对这个推出了走 443 端口的 SSH 服务。

如果需要将默认 22 端口改为 443，可编辑 SSH 配置：

nano ~/.ssh/config

添加以下内容：

Host github.com
  HostName ssh.github.com
  User git
  Port 443
  IdentityFile ~/.ssh/id_rsa

保存退出后，即可通过 ssh -T git@github.com 走 443 端口连接。

8. 提交与推送

git add .
git commit -m "first commit"
git push -u origin master

✅ 至此，本地即可通过 SSH 安全连接到 GitHub 并管理远程仓库。

Github Code Spaces 使用指南

GitHub Codespaces 是 GitHub 提供的一种基于云的开发环境，允许开发者在浏览器中直接编写、运行和调试代码。以下是使用 GitHub Codespaces 的详细指南：

1. 创建 Codespace

登录到你的 GitHub 账号。
进入你想要使用的仓库页面。
点击页面右上角的绿色Code按钮。
在下拉菜单中选择Open with Codespaces。
点击New codespace按钮，GitHub 会自动为你创建一个新的 Codespace。

2. 配置 Codespace

创建完成后，Codespace 会在浏览器中打开一个新的窗口。
你可以选择不同的开发环境（如 Node.js、Python、Java 等）来配置你的 Codespace。
你还可以通过编辑 .devcontainer/devcontainer.json 文件来自定义开发环境。

3. 使用 Codespace

在 Codespace 中，你可以像在本地开发环境中一样编写代码。
你可以使用内置的终端来运行命令行操作。
你可以安装扩展来增强你的开发体验。
你可以使用 Git 来管理你的代码版本。

4. 保存和关闭 Codespace

Codespace 会自动保存你的更改。
当你完成工作后，可以点击右上角的Codespaces按钮，然后选择Stop codespace来关闭它。
你可以随时重新打开你的 Codespace，所有的更改都会被保留。

5. 删除 Codespace

如果你不再需要某个 Codespace，可以点击Codespaces按钮。
找到你想要删除的 Codespace，点击旁边的“...”按钮。
选择Delete codespace来删除它。

6. 注意事项

Codespaces 可能会产生费用，具体取决于你的使用时间和资源消耗。
确保你了解 GitHub 的 Codespaces 定价政策，以避免意外费用。
Codespaces 适合短期项目和快速原型开发，对于长期项目，建议使用本地开发环境。

你也可以使用VScode网页版本直接登录GitHub账户，选择存储库进行编辑，如需要终端测试，请点击终端，直接自动生成Github Code Spaces终端

当然不用担心费用问题，GitHub Code Spaces提供了免费额度，足够我们日常使用

探索Github有意思的存储库

这里没啥好说的，主页进去就可以看。。。但是在搜索的时候一定要 关闭网页自动翻译 !

Author: Frees Ling

本地部署AI方法

Wed, 13 Aug 2025 00:00:00 GMT

本地化部署AI实施方法及测试

起因：今日上午九点半是谷歌中国开发者大会，我观看了直播并注册了谷歌开发者身份，一般而言每次公布新模型我并不会感到惊讶，正如这次Google Gemini，令我比较意外的还是这次更新的模型仅仅只有2GB，这么低廉的成本引发了我的好奇心，借着这股劲，我部署了本地AI（Google Gemini 2GB模型还在开发中，尚未公布所以部署了其他模型）

配置（个人配置，仅供参考）：
电  脑：联想拯救者Y7000P
处理器：AMD Ryzen 9 8945HX with Radeon Graphics  2.50 GH
显  卡：NIVDIA RTX 5060
内  存：16GB

ChatGPT oss-20B

两类模型介绍

由于OpenAI公司开源了两大AI，所以这次我们将使用其中的小模型进行部署 Click this你将会看到以下界面

这里我们可以根据自身电脑配置需求进行选择，这里的20B模型刚刚好可以满足我的电脑配置，所以这里我们将以20B模型进行演示，当然如果进不去OpenAI网页，下面我将提供两个模型对应的Hugging Face存储库

ChatGPT oss-20B ChatGPT oss-120B

什么是Hugging Face？

Hugging Face是通用的AI源代码存储地，在这里你可以找到绝大多是开源AI

下面是官方对于两类模型的简单介绍

gpt-oss-20b 适用于较低延迟和本地或特殊用例（210 亿个参数，其中 36 亿个活动参数）

gpt-oss-120b适用于生产、通用、高推理用例，适合单个 80GB GPU（如 NVIDIA H100 或 AMD MI300X）（117B 参数，其中 5.1B 活动参数）

这里我们选择LM studio作为载体来运行我们的AI，下面我将介绍LM studio的安装方法以及简单的配置下载

LM studio & 模型下载

你可以进入LM studio官网，你将会看到一下页面这里直接下载即可，下载完成后，打开LM studio界面将如下所示

打开后，请复制以下代码再回到LM studio（选择合适自己的进行复制）

# gpt-oss-20b
lms get openai/gpt-oss-20b
# gpt-oss 120b
lms get openai/gpt-oss-120b

复制完成后应该会自动识别剪切板进行询问下载，如若没有显示，请打开左侧栏的发现，进去后搜索gpt-oss-20b（120b）直接下载即可，如下图等待全部下载完成后，加载我们的模型就可以直接使用啦！

LM studio 汉化

在右下角的设置点击进去即可找到语言选择，选择自己喜好的语言即可

stable-diffusion-v1-4

介绍

这个模型是一个图片生成的模型（这个模型比较小，别指望生成精致的图片，图一乐即可哈哈哈哈哈）同样的可以在Hugging Face找到此模型 stable-diffusion-v1-4

安装必备库

由于模型的特殊性，这里我们需要借助Python进行安装和使用，本模型依赖Pytorch插件，所以请先下载相关库

pip install --upgrade diffusers transformers scipy
pip install torch torchvision torchaudio --index-url https://download.pytorch.org/whl/cu118

diffusers：Hugging Face 提供的开源库，用来加载和运行扩散模型（Stable Diffusion 就是扩散模型）。
transformers：管理模型结构和相关任务的通用库。
scipy：科学计算库，扩散模型运行时可能用到。

全部安装完成后，请在终端输入以下代码来检查显卡加速是否生效

python -c "import torch; print(torch.cuda.is_available())"

若返回True即生效

首次使用操作方法

请一定要看完全部再按照以下文档再自己选择合适的方法操作 请在代码编辑器中新建py文档进行首次下载和测试

import torch
from diffusers import StableDiffusionPipeline

def main():
    model_id = "CompVis/stable-diffusion-v1-4"
    device = "cuda" if torch.cuda.is_available() else "cpu"

    # 加载模型，float16 省显存（显卡显存低于4GB一定要用）
    pipe = StableDiffusionPipeline.from_pretrained(model_id, torch_dtype=torch.float16)
    pipe = pipe.to(device)

    # 如果显存有限，启用切片减少占用
    pipe.enable_attention_slicing()

    prompt = "a photo of an astronaut riding a horse on mars"
    print(f"Generating image for prompt: {prompt}")

    image = pipe(prompt).images[0]

    # 保存生成的图片
    image.save("astronaut_rides_horse.png")
    print("Image saved as astronaut_rides_horse.png")

if __name__ == "__main__":
    main()

当然这里默认模型安装路径就是和python安装路径是一样的，如果你的python和我的一样是在C盘内，那么我们可以通过更改一下步骤进行换到其他盘里面去例如，我想把模型下载到D盘里面的Models文件夹，那么我们可以对刚刚的代码进行以下更改

import os
import torch
from diffusers import StableDiffusionPipeline

# 先设置环境变量（可选）
os.environ["HF_HOME"] = "D:/models" # 可以更改到自己想到的地方
os.environ["TRANSFORMERS_CACHE"] = "D:/models" # 路径同上

def main():
    device = "cuda" if torch.cuda.is_available() else "cpu"
    pipe = StableDiffusionPipeline.from_pretrained(
        "CompVis/stable-diffusion-v1-4",
        cache_dir="D:/models",
        torch_dtype=torch.float16
    )
    pipe = pipe.to(device)
    pipe.enable_attention_slicing()

    prompt = "a photo of an astronaut riding a horse on mars"
    image = pipe(prompt).images[0]
    image.save("astronaut_rides_horse.png")
    print("Image saved.")

if __name__ == "__main__":
    main()

当然这里又出现了一个疑问，我们的生成的图像保存在哪里呢？注意这里

image.save("astronaut_rides_horse.png")

如果我们想要保存在桌面，我们可以进行如下修改

image.save("XXX/Desktop/astronaut_rides_horse.png")

这里的astronaut_rides_horse.png名称可以自定义

初次运行会进行模型下载工作，这里我们只需要等待即可（需要梯子）等到Image saved出现，那么恭喜你，首次使用大获成功

后续使用的操作

如果说我们再次运行上面的程序，那么就会造成二次下载，所以现在我们需要编写一个新程序进行后续长期的使用下面我将提供一套标准模板进行调用模型和使用（支持单次/多次使用）

import os
import torch
from diffusers import StableDiffusionPipeline

# -----------------------------
# 1. 设置模型路径和缓存目录
# -----------------------------
MODEL_PATH = r"D:/models/stable-diffusion-v1-4"  # 本地模型目录
OUTPUT_DIR = r"D:/models/output"                 # 输出图片保存目录

os.makedirs(OUTPUT_DIR, exist_ok=True)

# -----------------------------
# 2. 初始化模型 (只做一次)
# -----------------------------
device = "cuda" if torch.cuda.is_available() else "cpu"

pipe = StableDiffusionPipeline.from_pretrained(
    MODEL_PATH,
    torch_dtype=torch.float16  # 节省显存
).to(device)

pipe.enable_attention_slicing()  # 显存优化，尤其显卡小于8GB

# -----------------------------
# 3. 定义生成图片函数
# -----------------------------
def generate_image(prompt, filename):
    """生成图片并保存"""
    image = pipe(prompt).images[0]
    save_path = os.path.join(OUTPUT_DIR, filename)
    image.save(save_path)
    print(f"Image saved: {save_path}")

# -----------------------------
# 4. 批量生成示例
# -----------------------------
prompts = [
    ("a fantasy landscape with dragons", "dragons.png"),
    ("a futuristic city at sunset", "city.png"),
    ("a cute cat wearing a spacesuit", "cat.png")
]

for prompt_text, filename in prompts:
    generate_image(prompt_text, filename)

print("All images generated!")

请根据需求，适当修改上述代码当我们终于搞定时，去运行结果发现又报错了，这个原因是因为我们的初次下载的模型所在目录是有问题的，我们需要重新构建文件树首次下载的文件树是

D:.
├─blobs
├─refs
└─snapshots
    └─133a221b8aa7292a167afc5127cb63fb5005638b
        ├─feature_extractor
        ├─safety_checker
        ├─scheduler
        │  └─.ipynb_checkpoints
        ├─text_encoder
        ├─tokenizer
        ├─model_index.json
        ├─unet
        └─vae

这个时候我们需要在同文件夹下（我原来下载在Models文件夹下，那么同样在Models里面新建一个stable-diffusion-v1-4文件夹，把snapshots/133a221b8aa7292a167afc5127cb63fb5005638b/下所有文件（夹）复制进去然后把这个新文件夹的路径设置为Model Path即可使用以下是示例生成图片所以说玩玩乐呵乐呵就行了

2025极兽聚

Sun, 03 Aug 2025 00:00:00 GMT

2025 极兽聚记

认识了许多新朋友，当然也扩列了许多

福挞；镜风；马统君（？

SFF-04.jpg：；
SFF-03.jpg：；
sff-02.jpg：；
SFF-01.jpg：；
SFF-08.jpg：；
SFF-07.jpg：；
SFF-06.jpg：；
SFF-05.jpg：；

第一个正式博客

Sun, 06 Jul 2025 00:00:00 GMT

Frees Ling

What is the meaning of meeting?

恋爱摘录 1.0

在Ubuntu上的另类代码编写

前言

方法

YOLO训练推荐配置

前言

程序

PyCharm

GPU

YOLO训练中产生的问题及解决方案

前言

错误原因和错误重现

解决方案

后续训练

YOLO新应用-反馈图表解析

前言

项目架构

开始训练

反馈图解释

F1 Score（F1 分数）

Precision（精确率）

Recall（召回率）

PR Curve（Precision-Recall 曲线）

mAP（Mean Average Precision，平均精度）

Confusion Matrix（混淆矩阵）

YOLO新应用-数据标注篇

前言

是时候更新一下新技术了！

X-AnyLabeling

入门使用

第一步：设置输入输出文件夹

第二步：数据标注

第三步：导出数据

Python3.10另类常用安装方法

前言

编译所需要的工具链

下载Python3.10源码

编译安装

PIP安装

选修：另类高效常用包管理器——UV

第一种安装方法

第二种安装方法

项目开发随笔 v1.0

一键安装Vscode Ubuntu

配置Git及密钥

Ubuntu20.04.x LTS 配置C/C++环境

ROS系统安装

管道巡检代码复刻(足球无人机)

第三方库安装

Eigen（线性代数库）

OpenCV2

OpenCV2 编译版

Unitree Go2 基础开发演示及配置

Unitree Go2 基础开发演示及其配置

Author: Frees Ling

一、准备工作

二、简要介绍

三、具体操作步骤

1. 使用网线连接机器人和电脑

2. 配置电脑网络

3. 下载克隆官方ROS2，SDK

官方教程

4.使用VS code SSH远程连接机器人

5.运行Hello world DEMO程序

注意⚠️：本文档只按照当前系统环境进行操作

运行完成后，我们可以通过运行ROS2来检查自己是否真的启动了ROS2环境 如果上面完成后，那么恭喜你，已经解决了99%的问题，还剩下最后1%的问题<br>

编译程序

恭喜你，完成了Unitree Go2二次开发入门

Simple-AI

构建一个简单的AI模型入门指南

引言

关于AI模型

AI的本质是什么？如何去定义一个AI？

组成要素

判断一个AI

分类

构建一个简单的AI模型（以二分类为例）

实现步骤（理论）

运行完成后，我们可以通过运行`ROS2`来检查自己是否真的启动了ROS2环境如果上面完成后，那么恭喜你，已经解决了99%的问题，还剩下最后1%的问题<br>