# 基于YOLOV8的垃圾分类与识别系统

**Repository Path**: nhp_new/waste-sorting

## Basic Information

- **Project Name**: 基于YOLOV8的垃圾分类与识别系统
- **Description**: 一组的努力成果！
- **Primary Language**: Unknown
- **License**: Not specified
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 1
- **Forks**: 1
- **Created**: 2025-07-23
- **Last Updated**: 2025-08-03

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

基于YOLOV8的垃圾分类检测项目文档

一、前端：
总述:
前端使用C++Qt进行设计，实现了根据上传的静态图片进行识别，或开启摄像头进行实时捕获识别两种模式，识别支持用户自己通过不同的需求来调整模型的置信度阈值和IOU阈值控制模型的检测强度以得到个性化的结果，同时用户可以根据服务器的数据库查看自己识别的历史记录。
静态图片的上传和识别:
    静态图片上传: 静态图片上传使用了按钮信号槽绑定了C++Qt自带的文件管理器getOpenFileName事件让用户文件的选择要上传的图片，通过对用户选择图片路径的读取就可以获得pixmap形式的目标图片，再将目标图片通过*输入规范化*的方式变为模型标准的输入尺寸并显示在UI界面的图片框上。
*输入规范化*：由于YOLOv8模型在训练时的输入图像都是标准的640x640大小自带的将图片通过缩放拉伸的方式并不会保持原图像宽高比，这通常会导致原图像失真，让原图像中的物体失去原本的特征。 所以在用户端上传图片时需要先对原图像进行保持宽高比的缩放，宽或高较长的一边缩放为640，另一边在保证比例的情况下缩放为小于等于640的尺寸居中摆放，空出的空间将被填充黑边。这样就得到了640x640且保持原图像宽高比的标准输入图像，有利于提高模型识别的准确率。
 
    静态图片识别: 图片的识别要将原图片与请求头打包，通过创建网络访问管理器QNetworkAccessManager以http请求的方式发送给后端服务器，与服务器的FastAPI指定的端口进行通信，从而将图片以流的形式传入到服务器，进行识别。 模型识别完成后会同样以流的形式将图中被识别到的所有物体的类名、置信度、框出位置返回给前端的网络访问管理器，通过解析后端返回的数据就可以实现在本地对图像进行识别框的绘制，和识别信息的展示。
摄像头实时捕获和识别:
    调用摄像头: 使用availableCameras检索设备所有可用摄像头并将这些摄像头保存到列表中供用户选用，采用opencv库根据用于户选择的摄像头在列表中的索引进行调用。
qDebug() << "正在搜索设备摄像头...";
    cameralist = QCameraInfo::availableCameras();
    if(cameralist.isEmpty())
    {
        qDebug() << "没有找到符合要求的设备";
        return;
    }
    else
    {
        qDebug() << "找到摄像头:";
//        qDebug() << cameralist;
        qDebug() << "设备数:" << cameralist.length();
        ui->cameralist_Box->clear();//添加之先清空
        ui->cameralist_Box->addItem("<None>");
        for(int i=0;i<cameralist.length();i++)
        {
            qDebug() << "-------------------------------------------------------------------------------";
            qDebug() << "设备<" << i+1 << ">:";
            qDebug() << "     设备名称(描述):" << cameralist[i].description();
            qDebug() << "     设备路径:" << cameralist[i].deviceName();
            qDebug() << "     物理位置:" << cameralist[i].position();
            /*物理位置:安装的方式
             * FrontFace-前置
             * BackFace-后置
             * UnspecifiedPosition-未指定/USB外接摄像头(大多数情况)
            */
            qDebug() << "     旋转角度:" << cameralist[i].orientation() << "°";
 
            ui->cameralist_Box->addItem(cameralist[i].description());
        }
        qDebug() << "-------------------------------------------------------------------------------\n";
    }
    定时截取帧并显示: 在子线程设置一个定时器就可以通过循环定时来截取opencv调用的摄像头的画面，将截取画面的数据解析成pixmap格式就可以显示在面板上，达到类似摄像头实时显示的效果。
*定时器线程:
#ifndef TIMERPOSTTH_H
#define TIMERPOSTTH_H
 
#include <QThread>
#include <QTimer> //再此进行耗时操作
#include <QDebug>
 
class timerpostth : public QThread
{
    Q_OBJECT
 
public:
    explicit timerpostth(QObject *parent = nullptr);
    ~timerpostth();
 
    QTimer *timer;
 
protected:
    void run() override;
 
signals:
    void timeoutSignal();
 
public slots:
    void tevent();
};
#include "timerpostth.h"
 
timerpostth::timerpostth(QObject *parent) : QThread(parent)
{
    timer = nullptr;
}
 
void timerpostth::run()
{
    timer = new QTimer(this);
    timer->setInterval(45);  // 设置定时器间隔为毫秒
    connect(timer,SIGNAL(timeout()),this,SLOT(tevent()));
    timer->start();
    exec();
}
 
void timerpostth::tevent()
{
//    qDebug() << "计时器运行";
    emit timeoutSignal();
}
 
timerpostth::~timerpostth()
{
    if(timer != nullptr)
    {
        delete timer;
        qDebug() << "释放timer";
    }
    qDebug() << "子线程销毁";
}
 
通过websocket发送视频帧: 鉴于实时视频捕获识别需要很高的上传效率和响应速度，所以对比Websocket和http传输方式，得出websocket是全双工通信，具有更低的延迟和更高的传输效率，适合需要快速响应的场景，如实时视频监控、视频会议等，同时websocket支持直接传输二进制数据，省去了http传输二进制需要打包数据的这一环节，进一步节省了发送和响应时间。
*完整截图上传:
void ljflapp::catchpic()
{
    vc >> catched;//截取帧(整个摄像头屏幕)
    if(catched.empty())
    {
        qDebug() << "没有摄像头数据！";
        return;
    }
//    qDebug() << "截取摄像头的数据" << catched.data;
    if(changer == nullptr)
    {
        changer = new cv2pixmap(this);
        connect(changer,SIGNAL(turnfinish(QPixmap)),this,SLOT(setcvpix(QPixmap)));
        connect(changer,SIGNAL(bytefinish(QByteArray)),this,SLOT(postbyte2webs(QByteArray)));
    }
    if(!changer->isRunning())
    {
        changer->start();
    }
    changer->data2pixmap(catched);
    if(ui->run_btn->text() == "停止捕获")
    {
//        qDebug() << "开始上传";
        //1.catched转字节流
        if(webs != nullptr)
        {
            changer->turnbyte(catched);
        }
    }
}
*转字节流线程函数：
void cv2pixmap::turnbyte(const Mat& mat)
{
    std::vector<uchar> buffer;
    cv::imencode(".png", mat, buffer); // 将图像编码为PNG格式的字节流
 
    // 将字节流转换为QByteArray
    QByteArray bytedata(reinterpret_cast<char*>(buffer.data()), buffer.size());
    emit bytefinish(bytedata);
}
*websocket传输的问题与解决:在websocket传输过程中，发现了在服务器响应速度或客户端接收速度变慢时，websocket通道可能会出现自动断开的现象，为解决此问题就需要判断其是否在传输过程非自然中断，若是则需要直接重新启动webscket通信。
*websocket断开链接触发的槽函数:
void ljflapp::webdis()
{
    qDebug() << "ws通道断开连接";
    if(ui->run_btn->text() == "停止捕获")
    {
        qDebug() << "正在尝试重启...";
        webs = new QWebSocket();
        connect(webs,SIGNAL(connected()),this,SLOT(webcon()));
        connect(webs,SIGNAL(disconnected()),this,SLOT(webdis()));
        connect(webs,SIGNAL(binaryMessageReceived(QByteArray)),this,SLOT(dealbyte(QByteArray)));
 
        QString host_url_str = ui->url_Edit->text().trimmed();
        urlstr = "ws://" + host_url_str + ":8500/ws/detect";
        if (ui->zx_Edit->text() != "")
        {
            urlstr += "?conf_thres=" + ui->zx_Edit->text();
        }
        if (ui->IOU_Edit->text() != "")
        {
            urlstr += "&iou_thres=" + ui->IOU_Edit->text();
        }
        webs->open(QUrl(urlstr));
    }
    else
    {
//        poster->quit();
        webs->deleteLater();
        webs = nullptr;
        ui->run_btn->setText("开始捕获");
        if(ui->shotput_btn->text() != " 点击退出")
        {
            ui->clear_btn->setEnabled(true);
            ui->fileputup_btn->setEnabled(true);
        }
        ui->run_btn->setEnabled(true);
    }
}
二、后端 服务器：
核心功能
后端服务承担了多项关键任务，确保垃圾分类流程的自动化与智能化。
图片上传与处理
系统提供强大的图片上传与处理能力，作为整个数据流的入口。它能够高效地接收通过 HTTP POST 请求提交的图片文件，并对这些文件执行严格的格式验证，确保只处理如 JPG、PNG 等支持的图片类型，以维护系统稳定性和数据质量。一旦图片通过验证，其原始数据会被安全地存储到服务器的指定目录中，并且后端会返回一个 JSON 格式的响应。这个响应包含了图片处理和目标检测的结果，以及一些元数据。在处理过程中，后端会利用 OpenCV 库将接收到的二进制图片数据解码为 NumPy 数组（OpenCV 图像格式），这为后续的深度学习分析奠定了坚实的基础，确保图像数据以模型可接受的格式进行传递。
@app.post("/detects")
async def detect(image: UploadFile = File(...)):
    contents = await image.read()
    img_cv2_np = cv2.imdecode(np.frombuffer(contents, np.uint8), cv2.IMREAD_COLOR)
    # ... 后续的保存与处理逻辑 ...
 
深度学习目标检测
核心的深度学习目标检测功能是本项目的关键所在，它赋予了系统识别和分类垃圾的能力。本项目深度集成了 YOLOv8 模型，该模型通过 Ultralytics 库实现，以其卓越的性能和效率著称。系统能够对上传的图片或实时视频帧执行高效的目标检测，精确识别图片中不同垃圾的类别并定位其精确的边界框。为了满足不同场景和应用需求，系统还支持灵活配置检测的置信度阈值（conf_thres）和交并比阈值（iou_thres）。这些参数允许用户根据实际情况调整检测的灵敏度和精度，例如在需要高召回率时降低置信度阈值，或在需要高精确度时提高阈值，从而适应各种复杂的检测环境。
# 模型加载（在服务启动时完成，确保模型已预加载到内存中）
model = YOLO('bestv88.pt')
model.to(device) # 将模型加载到CPU或GPU设备
 
# 推理函数示例，接收OpenCV格式的图像，并返回检测结果
def run_inference(img_cv2_np: np.ndarray, conf_thres=0.3, iou_thres=0.3):
    # model.predict 负责图像预处理、推理和非极大值抑制（NMS）
    results_list = model.predict(source=img_cv2_np, conf=conf_thres, iou=iou_thres)
    detections = []
    for result in results_list: # 遍历每个图像的推理结果
        for box in result.boxes: # 遍历图像中的每个检测框
            x1, y1, x2, y2 = map(int, box.xyxy[0].tolist()) # 提取边界框坐标
            conf = round(float(box.conf[0]), 3) # 提取置信度
            label = model.names[int(box.cls[0])] # 提取类别标签
            detections.append({"label": label, "conf": conf, "bbox": [x1, y1, x2, y2]})
    return detections
检测结果可视化
完成深度学习检测后，系统会进行直观的检测结果可视化，以便用户清晰地理解分析结果。后端会在原图上智能地绘制出对应的边界框，精确框定检测到的垃圾对象。同时，在每个边界框旁，系统会清晰标注检测到的类别标签（如“塑料瓶”、“纸板”）和相应的置信度分数。这些带有可视化结果的图片随后会被保存到服务器的特定目录中。前端可以通过请求这些图片的 URL 来进行展示或用户进行下载，确保用户能够直观、准确地理解检测结果，无需额外的客户端处理。
 
def save_image_with_boxes(image_np: np.ndarray, detections: list, save_path: str):
    image = image_np.copy() # 创建图像副本以进行绘制
    for det in detections:
        x1, y1, x2, y2 = map(int, det.get("bbox"))
        label = det.get("label")
        conf = det.get("conf")
        cv2.rectangle(image, (x1, y1), (x2, y2), color=(0, 0, 255), thickness=2) # 绘制红色边界框
        # 绘制类别标签和置信度
        cv2.putText(image, f"{label} {int(conf * 100)}%", (x1, y1 - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.6, (255, 255, 255), 1)
    cv2.imwrite(save_path, image) # 保存绘制后的图像
 
实时视频流检测 (WebSocket)
除了静态图片处理，后端还支持高效的实时视频流检测。通过提供 WebSocket 端点，系统允许前端客户端（如桌面应用）发送连续的视频帧。对于接收到的每一帧，系统都将进行实时检测，并将检测结果（包括处理后的图片URL和详细检测数据）以二进制 JSON 格式即时回传给客户端，从而实现流畅、低延迟的实时交互体验，极大地提升了用户感知的响应速度，特别适用于需要即时反馈的场景。
@app.websocket("/ws/detect")
async def websocket_detect(websocket: WebSocket):
    await websocket.accept() # 接受WebSocket连接
    while True:
        data = await websocket.receive_bytes() # 接收前端发送的二进制视频帧
        img_cv2 = cv2.imdecode(np.frombuffer(data, np.uint8), cv2.IMREAD_COLOR) # 解码图像
        # 异步执行推理，避免阻塞主事件循环
        detections, saved_path = await run_in_threadpool(lambda: process_frame(img_cv2))
        response_data = {"detections": detections, "result_url": saved_path}
        await websocket.send_bytes(json.dumps(response_data).encode('utf-8')) # 将结果以二进制JSON格式回传
 
历史记录管理
为了方便用户管理和回顾，后端还提供了健全的历史记录管理功能。每次成功的图片检测结果，包括检测的时间戳和处理后的图片 URL，都会被持久化存储到轻量级的 SQLite 数据库中。同时，系统提供了 HTTP GET 接口，允许前端方便地查询和获取指定用户的历史检测记录，支持用户对过往操作进行回顾和分析，从而形成一个完整的检测闭环。
 
def save_detection_record(username: str, timestamp: str, result_url: str):
    with sqlite3.connect(DB_PATH) as conn:
        cursor = conn.cursor()
        cursor.execute("INSERT OR IGNORE INTO users (username) VALUES (?)", (username,)) # 确保用户存在
        user_id = cursor.fetchone()[0] # 获取用户ID
        cursor.execute("INSERT INTO detection_history (user_id, timestamp, result_image_url) VALUES (?, ?, ?)", (user_id, timestamp, result_url))
        conn.commit() # 提交事务
 
def get_user_history(username: str):
    with sqlite3.connect(DB_PATH) as conn:
        cursor = conn.cursor()
        cursor.execute("SELECT h.timestamp, h.result_image_url FROM detection_history h JOIN users u ON h.user_id = u.id WHERE u.username = ? ORDER BY h.id DESC", (username,))
        return [{"timestamp": r[0], "result_image_url": r[1]} for r in cursor.fetchall()] # 返回格式化后的历史记录
 
基于 IP 的数据隔离
在数据管理方面，项目采取了精巧的基于 IP 的数据隔离设计。系统会根据客户端的 IP 地址，为每个独立的用户动态创建专属的图片上传和结果存储目录。这种机制确保了不同用户的检测数据和文件能够完全隔离，从而显著提升了数据管理的安全性、私密性与清晰度，有效避免了数据混淆的风险，为多用户环境提供了可靠的数据保障。
def get_client_ip(request: Request):
    return request.headers.get("X-Forwarded-For") or request.client.host
 
# ... 在处理请求时，根据IP创建目录 ...
client_ip = get_client_ip(request)
current_upload_dir = BASE_UPLOAD_DIR / client_ip.replace(":", "_").replace(".", "_")
current_result_dir = BASE_RESULT_DIR / client_ip.replace(":", "_").replace(".", "_")
current_upload_dir.mkdir(parents=True, exist_ok=True) # 确保目录存在
current_result_dir.mkdir(parents=True, exist_ok=True)
 
最后，为了便于前端展示和用户访问，后端还提供了直观的结果图片服务。通过一个专门的 HTTP GET 接口，前端可以依据数据库中存储的 URL 轻松请求并获取经过深度学习模型处理和可视化后的结果图片，实现无缝的图片展示体验，完善了整个数据流的闭环。result_image API 不会被直接调用，而是作为静态资源服务的一部分。它在后端生成了处理后的图片链接后，由前端通过 HTTP GET 请求来访问这个链接时，才会被后端触发，从而将对应的图片文件以流的形式返回给前端进行展示。
 
@app.get("/result_image/{ip_dir}/{filename}")
async def get_result_image(ip_dir: str, filename: str):
    result_path = BASE_RESULT_DIR / ip_dir / filename
    if not result_path.exists():
        raise HTTPException(status_code=404, detail="处理图像不存在")
    return StreamingResponse(result_path.open("rb"), media_type="image/jpeg")
 
技术栈
本项目后端基于 Python 语言构建，并采用 FastAPI 这一现代化的 Web 框架来构建高性能、异步的 API 接口，充分利用了其简洁的语法和自动文档生成能力。服务的运行依赖于 Uvicorn 作为 ASGI 服务器，它能够高效地处理异步操作和高并发请求。在核心的深度学习部分，我们使用了 PyTorch 深度学习框架来支持 YOLOv8 模型的运行，并通过 Ultralytics 库简化了模型的加载和推理流程。图像处理方面，OpenCV (cv2) 和 NumPy 提供了强大的工具集，用于图像数据的读取、操作和高效处理。所有检测历史记录都存储在轻量级的关系型数据库 SQLite3 中，确保数据的持久化和便捷查询。为了解决 Python 同步阻塞操作可能带来的性能瓶颈，我们利用 FastAPI 提供的 run_in_threadpool 工具，将深度学习推理等 CPU 密集型或 I/O 密集型任务放入独立的线程池执行，从而避免阻塞主事件循环，保持了系统的高响应性。此外，项目还广泛使用了 Python 标准库，例如 pathlib 用于更现代、面向对象的文件路径操作，shutil 用于高级文件和目录操作，Pillow (PIL fork) 用于图像验证，uuid 用于生成唯一标识符，datetime 用于日期时间处理，以及 logging 用于系统日志记录。在生产部署方面，我们选择了 Gunicorn 作为生产级的 WSGI/ASGI HTTP 服务器，它能够有效管理 Uvicorn worker 进程，提供多进程并发能力，确保应用在实际运行环境中的稳定性和高性能。
架构亮点
本项目的架构设计融合了多项关键特性，以确保服务的高性能、高可靠性和可维护性。
高性能异步设计
其核心在于高性能异步设计，充分利用了 FastAPI 和 Uvicorn 的异步能力。通过将 YOLOv8 模型推理等潜在的阻塞操作智能地放入由 run_in_threadpool 管理的独立线程池中执行，我们有效避免了主事件循环的阻塞，从而实现了服务的高并发处理能力和卓越的吞吐量，即使在高负载下也能保持快速响应。
RESTful API 与 WebSocket 结合
在 API 通信方面，项目巧妙地结合了 RESTful API 与 WebSocket。对于图片上传和历史数据查询等传统请求，我们提供了清晰、简洁的 RESTful API 端点（如 /detects、/history、/result_image）。而对于视频流的实时检测，则通过 WebSocket（/ws/detect）实现了低延迟、双向的通信，确保了视频帧的即时处理和结果反馈，极大地提升了用户在实时场景下的体验。
模块化与可维护性
项目的代码结构也体现了高度的模块化与可维护性。应用逻辑、数据库操作、模型推理以及各种辅助工具都被清晰地封装在独立的模块中。这种设计不仅提高了代码的可读性，使得新成员能够更快地理解项目，而且也极大地提升了代码的可维护性和未来的可扩展性，便于功能迭代和技术升级。
数据隔离机制
在数据管理方面，项目引入了独特的数据隔离机制。通过根据客户端的 IP 地址动态创建和管理独立的图片上传和结果存储目录，我们实现了用户数据间的有效隔离。这种基于 IP 的隔离策略简化了多用户环境下的数据管理流程，并增强了数据的安全性和私密性。
生产级部署准备
最后，本项目从一开始就考虑了生产级部署准备。通过集成 Gunicorn 作为 HTTP 服务器，我们能够有效地管理 Uvicorn 的多个 worker 进程。Gunicorn 提供了健壮的进程管理和负载均衡能力，确保了应用在实际运行环境中的稳定、高效运行，能够可靠地处理来自大量用户的并发请求。
 
三、模型训练（环境配置，调参方法）：
YOLOv5
yolov5需要的环境在requirements中：
环境搭建：连接服务器，打开root文件夹，在root文件夹下新建一个文件夹（随便起个名字），将模型移动到这个文件夹内，新建虚拟环境，在虚拟环境中把requirments.txt中的库安装好。
配置git环境
找到下载git的文件夹

添加环境变量，选择系统变量中的PATH，点编辑，然后点新建，选择浏览，增加红圈的内容。

最后验证一下是否添加成功
win+R,cmd，输入where git，出现下图所示，即为成功

1.  模型代码
基本结构：

datasets存放数据集：

images里是图片，labels里是标签

.github
这个文件夹通常用于存放与 GitHub 相关的配置文件，比如 GitHub Actions 工作流文件、ISSUE_TEMPLATE（问题模板）、PULL_REQUEST_TEMPLATE（拉取请求模板）等，用来自动化一些项目管理和持续集成相关的任务，例如代码的自动测试、构建等。
.idea
这是由 JetBrains 系列开发工具（如 PyCharm）自动生成的文件夹，用于存储项目的配置信息，像项目的结构、编译器设置、运行配置等。对代码的实际运行没有影响，一般在版本控制时会将其忽略。
classify
用于图像分类相关的代码和配置。在 YOLOv5 框架中，除了目标检测功能外，也支持图像分类任务，这个文件夹下可能包含分类模型的定义、训练脚本、测试脚本以及相关的数据处理代码等。
data
存放与数据相关的内容，包括数据集配置文件（比如定义数据集路径、类别名称等的 .yaml 文件 ）、预处理后的数据（如果有） 、标注文件等。在训练和测试目标检测模型时，需要从这里读取数据和相关配置。
models
该文件夹用于定义 YOLOv5 的模型结构。包含了不同版本的模型架构代码（比如 yolov5s.py、yolov5m.py 等，对应不同规模的模型），以及模型加载、初始化等相关的函数和类。
runs
当你训练或测试模型时，这个文件夹会保存运行的结果。比如训练过程中产生的日志、权重文件（.pt 文件）、验证结果可视化图片等；测试时生成的检测结果图片、检测报告等也会存储在这里。它按照不同的任务类型（如 train、detect 等）和运行时间来组织子文件夹，方便用户查看和管理每次运行的输出。
segment
与 classify 类似，是用于图像分割任务的代码和配置所在的文件夹。在这里可以找到分割模型的定义、训练分割模型的脚本、测试分割模型的脚本，以及相关的数据预处理和后处理代码。
utils
存放一些工具函数和辅助类。比如数据增强函数（用于在训练时对图像进行变换，增加数据多样性）、模型评估指标计算函数（如计算 mAP 等指标）、文件操作工具函数（读取和写入数据文件等）、可视化函数（绘制检测结果、损失曲线等） 等。这些工具函数可以被其他模块方便地调用，提高代码的复用性。
1. YOLOv8：
autodl的GPU部署大模型：
2.8 autodl的GPU部署大模型 (yuque.com)
vscode：相关知识

可将文件，数据存储在数据盘，路径如上图所示

可在autodl上选择扩容
模型训练代码：
首先下载ultralytics库，可以通过以下命令安装：
pip install ultralytics -i https://pypi.tuna.tsinghua.edu.cn/simple                          
模型训练的代码：
from ultralytics import YOLO
 
if __name__ == '__main__':
    model = YOLO('yolov8.yaml')  # 使用配置文件构建模型
    model.load('yolov8s.pt')  # 加载本地权重文件-
    results = model.train(
        data='waste_sorting_data.yaml',  # 数据集配置文件路径
        epochs=100,  # 训练轮数
        batch=128,  # 批量大小
        imgsz=640,  # 图像尺寸
        workers=8,  # 工作线程数
        device=0,  # 设备（0 表示 GPU）
        optimizer='SGD',  # 优化器
        amp=True,  # 是否使用混合精度训练
        cls=2.5,  # 提高分类损失权重（默认0.5），增强类别预测能力
        cos_lr=True,  # 启用余弦学习率调度，促进收敛
        patience=20,  # 早停机制：20轮无提升则停止
        dropout=0.1,  # 添加10% dropout，减轻过拟合
        augment=True,  # 启用数据增强（翻转、旋转等）
        mosaic=0.8,  # 降低mosaic强度（默认1.0），减少极端样本影响
        mixup=0.0,  # 禁用mixup，避免标签模糊
        conf=0.35,  # 降低置信度阈值，减少漏检
        cache=False  # 是否缓存数据集
    )
 
yolov8.yaml文件如下：
# Parameters
nc: 76 # 分的类别数量number of classes 
scales:s #模型大小 model compound scaling constants, i.e. 'model=yolov8n.yaml' will call yolov8.yaml with scale 'n'
  # [depth, width, max_channels]各个模型的深度，宽度和最大通道数
n: [0.33, 0.25, 1024] # YOLOv8n summary: 129 layers, 3157200 parameters, 3157184 gradients, 8.9 GFLOPS
s: [0.33, 0.50, 1024] # YOLOv8s summary: 129 layers, 11166560 parameters, 11166544 gradients, 28.8 GFLOPS
m: [0.67, 0.75, 768] # YOLOv8m summary: 169 layers, 25902640 parameters, 25902624 gradients, 79.3 GFLOPS
l: [1.00, 1.00, 512] # YOLOv8l summary: 209 layers, 43691520 parameters, 43691504 gradients, 165.7 GFLOPS
x: [1.00, 1.25, 512] # YOLOv8x summary: 209 layers, 68229648 parameters, 68229632 gradients, 258.5 GFLOPS
 
 
# 骨干网络，不同模型的骨干网络结构都一样，通过上面的参数来调动不同大小的模型
# YOLOv8.0n 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, 3, C2f, [128, True]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 6, C2f, [256, True]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 6, C2f, [512, True]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 3, C2f, [1024, True]]
  - [-1, 1, SPPF, [1024, 5]] # 9
 
# 检测头
# YOLOv8.0n head
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 3, C2f, [512]] # 12
 
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 4], 1, Concat, [1]] # cat backbone P3
  - [-1, 3, C2f, [256]] # 15 (P3/8-small)
 
  - [-1, 1, Conv, [256, 3, 2]]
  - [[-1, 12], 1, Concat, [1]] # cat head P4
  - [-1, 3, C2f, [512]] # 18 (P4/16-medium)
 
  - [-1, 1, Conv, [512, 3, 2]]
  - [[-1, 9], 1, Concat, [1]] # cat head P5
  - [-1, 3, C2f, [1024]] # 21 (P5/32-large)
 
  - [[15, 18, 21], 1, Detect, [nc]] # Detect(P3, P4, P5)
 
yolov8s.pt：使用以下代码可下载
from ultralytics import YOLO
 
# 加载模型，模型文件会自动下载
model = YOLO("yolov8s.pt")
print("YOLOv8s.pt 模型加载完成！")
将s改为n，m，l，x即可下载不同大小的模型
 
waste_sorting_data.yaml代码：
test: autodl-tmp/test/images  #测试集路径
train: autodl-tmp/train/images  #训练集路径
val: autodl-tmp/valid/images  #验证集路径
 
 
names:
 
    0: Recyclables Aerosols
    1: Recyclables Aluminum can
    2: Recyclables Aluminum caps
    3: Recyclables Cardboard
    4: Recyclables Cellulose
    5: Recyclables Ceramic
    6: Recyclables Combined plastic
    7: Recyclables Container for household chemicals
    8: Recyclables Disposable tableware
    9: Recyclables Electronics
    10: Recyclables Foil
    11: Recyclables Furniture
    12: Recyclables Glass bottle
    13: Recyclables Iron utensils
    14: Recyclables Liquid
    15: Recyclables Metal shavings
    16: Recyclables Milk bottle
    17: Other Trash Organic
    18: Recyclables Paper bag
    19: Recyclables Paper cups
    20: Recyclables Paper shavings
    21: Recyclables Paper
    22: Recyclables Papier mache
    23: Recyclables Plastic bag
    24: Recyclables Plastic bottle
    25: Recyclables Plastic canister
    26: Hazardous Plastic canister
    27: Recyclables Plastic caps
    28: Recyclables Plastic cup
    29: Recyclables Plastic shaker
    30: Recyclables Plastic shavings
    31: Recyclables Plastic toys
    32: Recyclables Postal packaging
    33: Recyclables Printing industry
    34: Other Trash Scrap metal
    35: Recyclables Stretch film
    36: Recyclables Tetra pack
    37: Recyclables Textile
    38: Recyclables Tin
    39: Recyclables Unknown plastic
    40: Kitchen Waste Wood
    41: Recyclables Zip plastic bag
    42: Kitchen Waste Ramen Cup
    43: Kitchen Waste Food Packet
    44: Kitchen Waste Apple
    45: Kitchen Waste Apple-core
    46: Kitchen Waste Apple-peel
    47: Kitchen Waste Bone
    48: Kitchen Waste Bone-fish
    49: Kitchen Waste Bread
    50: Kitchen Waste Bun
    51: Kitchen Waste Egg-hard
    52: Kitchen Waste Egg-scramble
    53: Kitchen Waste Egg-shell
    54: Kitchen Waste Egg-steam
    55: Kitchen Waste Egg-yolk
    56: Kitchen Waste Fish
    57: Kitchen Waste Meat
    58: Kitchen Waste Mussel
    59: Kitchen Waste Mussel-shell
    60: Kitchen Waste Noodle
    61: Kitchen Waste Orange
    62: Kitchen Waste Orange-peel
    63: Kitchen Waste Other-waste
    64: Kitchen Waste Pancake
    65: Kitchen Waste Pasta
    66: Kitchen Waste Pear
    67: Kitchen Waste Pear-core
    68: Kitchen Waste Pear-peel
    69: Kitchen Waste Potato
    70: Kitchen Waste Rice
    71: Kitchen Waste Shrimp
    72: Kitchen Waste Shrimp-shell
    73: Kitchen Waste Tofu
    74: Kitchen Waste Tomato
    75: Kitchen Waste Vegetable
 
 
数据集下载到服务器：
直接将文件夹拖入会因为超过粘贴板上限或其他原因导致传输不全，建议采用以下办法：
方法一：
在本地计算机将文件夹打包成zip文件，然后将zip文件复制到服务器，最后解压zip文件即可。
解压文件命令：
unzip -o <filename.zip> -d <autodl-tmp>
filename：要解压的文件
autodl-tmp：解压到的路径（这个是数据盘的路径）
 
方法二：
本地和autodl服务器进行文件互传
📎MobaXterm.7z
操作说明：
第一步：

第2步：

第3步：

第4步：

第5步：

 
YOLO格式数据集需要两个文件：

一个放图片，另一个放标签，标签文件夹中是txt文件，如图：

第一个数字1是编号，后面的是被归一化的方框的坐标。
 
完成以上步骤后即可运行模型训练的代码。
 
模型开始训练后有以下参数：

1. Epoch
含义：当前训练的轮数。
示例：1/100 表示当前是第 1 轮，总共计划训练 100 轮。
2. GPU_mem
含义：GPU 内存使用量。
示例：12.5G 表示当前 GPU 内存使用量为 12.5 GB。
作用：帮助你监控 GPU 资源的使用情况，确保训练过程中不会因为内存不足而导致训练中断。
3. box_loss
含义：边界框损失（Box Loss）。
示例：1.169 表示当前轮次的边界框损失值为 1.169。
作用：衡量模型预测的边界框与真实边界框之间的差异。值越小，表示边界框的预测越准确。
4. cls_loss
含义：分类损失（Classification Loss）。
示例：8.049 表示当前轮次的分类损失值为 8.049。
作用：衡量模型对目标类别预测的准确性。值越小，表示分类预测越准确。
5. dfl_loss
含义：分布焦点损失（Distribution Focal Loss）。
示例：1.549 表示当前轮次的分布焦点损失值为 1.549。
作用：这是 YOLOv8 中用于改进边界框预测的一种损失函数，结合了分布信息，帮助模型更好地学习边界框的分布。
6. Instances
含义：当前批次中检测到的目标实例数量。
示例：78 表示当前批次中检测到 78 个目标实例。
作用：帮助你了解模型在每个批次中检测到的目标数量，反映了模型的检测能力。
7. Size
含义：训练时使用的图像尺寸。
示例：640 表示训练时使用的图像尺寸为 640×640。
作用：帮助你确认训练时的图像输入尺寸是否符合预期。
8. Class
含义：类别信息。
示例：all 表示统计的是所有类别的综合结果。
作用：帮助你了解模型在所有类别上的综合性能。
9. Images
含义：处理的图像数量。
示例：2013 表示已经处理了 2013 张图像。
作用：帮助你了解训练过程中处理的图像数量。
10. Instances
含义：处理的实例数量。
示例：2970 表示已经处理了 2970 个目标实例。
作用：帮助你了解训练过程中处理的目标实例总数。
11. Box(P)
含义：边界框的精确率（Precision）。
示例：0.367 表示边界框的精确率为 36.7%。
作用：衡量模型预测的边界框中有多少是正确的。
12. Box(R)
含义：边界框的召回率（Recall）。
示例：0.306 表示边界框的召回率为 30.6%。
作用：衡量模型能够检测到的真实目标的比例。
13. mAP50
含义：平均精度（mAP）在 IoU=0.5 时的值。
示例：0.338 表示在 IoU=0.5 时的平均精度为 33.8%。
作用：衡量模型在 IoU=0.5 时的检测性能，是目标检测任务中常用的性能指标。
14. mAP50-95
含义：平均精度（mAP）在 IoU=0.5 到 IoU=0.95 之间的平均值。
示例：0.251 表示在 IoU=0.5 到 IoU=0.95 之间的平均精度为 25.1%。
作用：衡量模型在不同 IoU 阈值下的综合检测性能，更全面地反映模型的性能。
总结
这些参数共同反映了 YOLOv8 模型在训练过程中的性能和资源使用情况。通过监控这些指标，你可以更好地了解模型的训练进度，调整训练策略，优化模型性能。
四、模型部署：
 
1. 首先查看有无网络

也可以用ping www.baidu.com

2.然后进行以下下代码
这一步是用来完成安装docker
1.sudo apt update
2.sudo apt-get install apt-transport-https ca-certificates curl 3.software-properties-common lrzsz -y
4.sudo curl -fsSL https://mirrors.aliyun.com/docker-ce/linux/ubuntu/gpg | sudo apt-key add -
5.sudo add-apt-repository "deb [arch=amd64] https://mirrors.aliyun.com/docker-ce/linux/ubuntu $(lsb_release -cs) stable"

sudo docker ps：当前正在运行的 Docker 容器。
sudo docker images：列出本地所有已下载或构建的 Docker 镜像。
sudo docker rmi：指定要删除的镜像名称或 ID。
sudo docker stop：指定要停止的容器名称或 ID。
sudo docker rm：删除已停止的容器。
要删掉镜像，首先要先删掉镜像里运行的容器（一个镜像中可以运行多个容器），要先查看在运行的容器，停止容器的运行，然后删除容器，查看镜像，然后删除，如果删除失败会爆出还在运行的容器的ID号，此时再跳回到停止容器。
1. 查看doker版本
1. sudo docker version
2. sudo snap install docker

4.安装vim
1. sudo apt-get remove vim-common
2. sudo apt-get install vim

5.创建文件daemon.json
1.切换到/etc/docker
     cd /etc/docker
  2.创建文件deamon.json
sudo touch daemon.json
3.修改权限
sudo chmod 777 daemon.json
4.修改daemon.json文件
   sudo vi daemon.json
5.把下面的内容复制到daemon.json文件中并点击保存
{
"registry-mirrors": [
"https://docker-0.unsee.tech",
"https://docker-cf.registry.cyou",
"https://docker.1panel.live"
]}

按i进入插入模式

按：输入wq；进行保存

6.重启docker
sudo systemctl daemon-reload
sudo systemctl restart docker
至此，ubuntu上安装docker就完成了。
测试：输入这个命令 sudo docker pull alpine:latest 如果能正常下载镜像就说明配置正确