yolov5 加 MLflow

我要应用mlflow来追踪我的yolov5训练情况和metrics.
能夠透过修改 train.py 或其他方式来做到这点？

能问chatgpt的我都问过了，你要问gpt可以，但也要确定能work。

你可以把数据和代码发给我让我看一下吗？

参考下

import argparse
import torch
import yaml
from models.yolo import Model
from utils.loss import ComputeLoss
from utils.datasets import create_dataloader
from utils.general import (
    check_img_size, non_max_suppression, scale_coords,
    xyxy2xywh, plot_one_box, set_logging)
from utils.torch_utils import (
    init_seeds, ModelEMA, select_device, intersect_dicts)

import mlflow

def train(hyp, opt, device, tb_writer=None):
    # 创建 dataloaders、model、optimizer、criterion
    dataloader, val_dataloader = create_dataloader(opt)
    model = Model(opt.cfg).to(device)
    optimizer = torch.optim.SGD(model.parameters(), lr=hyp['lr'], momentum=hyp['momentum'], weight_decay=hyp['weight_decay'])
    criterion = ComputeLoss(model)  # 创建 loss 计算器

    # 创建 model EMA，此处使用默认权重 0.001
    ema = ModelEMA(model)

    # 开始训练循环
    for epoch in range(opt.epochs):
        # 定义统计量
        running_loss = 0.0
        running_iters = 0

        for i, (imgs, targets, paths, _) in enumerate(dataloader):
            model.train()
            imgs = imgs.to(device)
            targets = targets.to(device)

            # 在计算 loss 的时候，将 model 输出转换得到预测框信息，该信息将输出到 mlflow
            pred, loss_item = criterion(model(imgs), targets)
            loss_item = loss_item.mean()
            if not torch.isfinite(loss_item):
                print('Loss is non-finite!', loss_item, pred)
                continue

            optimizer.zero_grad()
            loss_item.backward()
            optimizer.step()

            # 更新 model EMA
            ema.update(model)

            # 记录训练状态
            if tb_writer is not None:
                tb_writer.add_scalar('train/giou_loss', loss_item, i + len(dataloader) * epoch)

            # 使用 NMS 计算预测的 bounding boxes
            det = non_max_suppression(pred, conf_thres=0.001, iou_thres=0.65, multi_label=False)

            # 将预测边界框指标记录到 mlflow
            # 这里仅仅记录了 confidence score 最高的一个预测框的指标，你也可以选择其他指标
            max_score = 0.0
            for i, d in enumerate(det):
                if d is not None and len(d):
                    max_score = max(max_score, d[0][4])
            mlflow.log_metric('train/max_confidence_score', max_score, epoch * len(dataloader) + i)

            # 参考下述，将部分 epochs 的信息保存为 checkpoints
            if (i + 1) % opt.checkpoint_interval == 0:
                torch.save(model.state_dict(), f'checkpoints/yolov5s_epoch_{epoch + 1}_iter_{i + 1}.pth')

        # 把 model EMA 的参数复制到模型参数上
        ema.update_attr(model)

        # 在 validation 阶段进行 validation，也可以参照上述在 training 阶段使用 MLflow 记录 metrics
        with torch.no_grad():
            pass

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument('--data', type=str, default='data/coco128.yaml', help='path to yaml data file')
    opt = parser.parse_args()
    # load hyperparameters，然后把当前的超参数添加到 mlflow 
    with open(opt.data) as f:
        hyp = yaml.load(f, Loader=yaml.FullLoader)['hyp']
        for k, v in hyp.items():
            mlflow.log_param(k, v)
    # ensure directory architecture exists
    ckpt_path = 'checkpoints'
    if not os.path.exists(ckpt_path):
        os.makedirs(ckpt_path)
    # train
    train(hyp, opt, device, tb_writer)
    # 训练完成，停止 mlflow 追踪
    mlflow.end_run()

该回答参考ChatGPT:
是的，你可以通过修改 train.py 文件或使用其他方式来使用 MLflow 来追踪 YOLOv5 的训练情况和指标。以下是一些可能的步骤：

在 train.py 文件中添加 MLflow 库的导入语句。
使用 MLflow.start_run() 开始一个新的 MLflow 实验，并设置相关参数。
在训练循环中使用 MLflow.log_metric() 记录每个 epoch 的指标值。
在实验结束时，使用 MLflow.end_run() 结束该次实验。
以下是一个使用 MLflow 进行 YOLOv5 训练追踪的示例代码：

import mlflow

# 定义 MLflow 实验参数
experiment_name = "yolov5_training"
mlflow.set_experiment(experiment_name)

# 开始一个新的实验
with mlflow.start_run():
    # 设置训练参数
    epochs = 10
    batch_size = 8
    learning_rate = 0.001
    
    # 在 MLflow 中记录训练参数
    mlflow.log_param("epochs", epochs)
    mlflow.log_param("batch_size", batch_size)
    mlflow.log_param("learning_rate", learning_rate)
    
    # 在循环中记录每个 epoch 的指标值
    for epoch in range(epochs):
        loss = train_one_epoch()
        val_loss = validate()
        
        # 在 MLflow 中记录指标值
        mlflow.log_metric("train_loss", loss, step=epoch)
        mlflow.log_metric("val_loss", val_loss, step=epoch)
    
    # 结束该次实验
    mlflow.end_run()

这只是一个简单的示例代码，具体的实现可能需要根据你的需求进行相应的调整。注意要在 train.py 文件中添加 import mlflow 来导入 MLflow 库。

具体实现可能会因应不同的需求而略有不同，可以根据官方文档进行相应的调整。

内容来源与ChatGpt4及newbing和百度：

可以通过修改train.py文件来实现在yolov5中使用mlflow来追踪训练情况和metrics。具体操作步骤如下：

安装mlflow库
```
!pip install mlflow
```
在train.py文件中引入mlflow库
```
import mlflow
```
在train.py文件中使用mlflow.start_run()开始一个新的mlflow运行
```
with mlflow.start_run():
 # Your training code here
```
在训练过程中，使用mlflow.log_metric()记录metrics
```
mlflow.log_metric("loss", loss_value)
```
在训练结束后，使用mlflow.end_run()结束mlflow运行
```
mlflow.end_run()
```

这样就可以使用mlflow来追踪yolov5的训练情况和metrics了。

以下是完整的示例代码：

import mlflow
from models.yolo import Model
from utils.datasets import *
from utils.utils import *

# Initialize model
model = Model()

# Start mlflow run
with mlflow.start_run():
    # Get dataloader
    dataloader = LoadImagesAndLabels(train_path, batch_size=batch_size, img_size=img_size)

    # Train loop
    for epoch in range(epochs):
        for i, (imgs, targets, paths, _) in enumerate(dataloader):
            loss, _ = model.train(imgs, targets)

            # Log loss metric
            mlflow.log_metric("loss", loss.item())

            # Print progress
            print("Epoch [{}/{}], Step [{}/{}], Loss: {:.4f}".format(epoch+1, epochs, i+1, len(dataloader), loss.item()))

    # End mlflow run
    mlflow.end_run()

祝您问题迎刃而解

以下答案由GPT-3.5大模型与博主波罗歌共同编写：
当您使用MLflow来追踪YOLOv5的训练情况和metrics时，您需要进行以下步骤：

安装MLflow库和YOLOv5库：您需要在您的系统上安装MLflow和YOLOv5库。
修改train.py文件：首先，在YOLOv5 train.py文件中添加代码以初始化MLflow。您需要设置实验名称和数据路径等参数，还需包括以下代码：
import mlflow
set experiment name
experiment_name = 'YOLOv5_Experiment'
initialize mlflow
mlflow.set_tracking_uri('file:///mnt/nfsroot/mlruns')
mlflow.set_experiment(experiment_name)
mlflow.start_run(run_name=run_name)
log parameters
mlflow.log_param('epochs', hyperparameters.get('epochs'))
mlflow.log_param('batch_size', hyperparameters.get('batch_size'))
other code for YOLOv5 training
在train.py文件中添加代码以记录MLflow metrics：
log metrics
mlflow.log_metric('train_loss', train_loss, step=epoch)

在train.py文件中添加代码以记录MLflow artifacts：

save model checkpoints

if (epoch + 1) % 5 == 0:

 saved_path = os.path.join('models', 'yolov5_{}.pth'.format(epoch + 1))
 torch.save(model.state_dict(), saved_path)
 mlflow.log_artifact(saved_path)

在train.py文件中添加代码以在模型训练完成后，结束MLflow run：
end mlflow run
mlflow.end_run()

以上代码仅仅是一个示例。因为YOLOv5的train.py文件可能会因个人需求而有所不同，需要根据具体情况进行相应调整。

希望以上代码能为你提供一些帮助，如果有遇到问题，请及时联系我。
如果我的回答解决了您的问题，请采纳！

安装MLflow和其他必要的库

您需要安装MLflow库和其他必要的库，如pandas和numpy。您可以使用pip命令在命令行中安装它们：

pip install mlflow pandas numpy

导入MLflow库

在您的train.py文件的顶部，请引入mlflow库并import其他必要的库。这是一个示例代码：

import mlflow
import os
import sys
import argparse
import time
import yaml
import torch.backends.cudnn as cudnn
import torch.optim as optim
import torch.utils.data
from models.experimental import attempt_load
from models.yolo import Model # 根据您的代码中的模型名称进行更改
from datasets import create_dataloader
from utils.general import (
    check_img_size, non_max_suppression, apply_classifier, scale_coords,
    plot_one_box, xyxy2xywh, strip_optimizer, set_logging)
from utils.augmentations import Albumentations
from utils.datasets import LoadImagesAndLabels
from utils.loss import ComputeLoss
from utils.torch_utils import (
    ModelEMA, select_device, intersect_dicts, torch_distributed_zero_first, de_parallel)


def main():
    parser = argparse.ArgumentParser()
    ...

初始化MLflow

为了开始使用MLflow追踪某个训练任务，您首先需要初始化MLflow。在train.py文件的顶部，您可以使用如下代码初始化MLflow：

# 设置MLflow tracking URI，如果您不设置，则会使用默认路径将metrics保存到本地。
tracking_uri = 'file:/home/user/mlruns'

if mlflow.active_run() is None:
    mlflow.set_tracking_uri(tracking_uri)
    mlflow.start_run(run_name='yolov5_experiment')

在这个例子中，我们使用了本地文件系统作为tracking URI，因此metrics将存储在/home/user/mlruns路径下。如果您不设置tracking URI，MLflow将默认将metrics存储在本地的mlruns路径下。

在训练中记录指标

在train.py文件的训练循环中，您可以使用MLflow来记录任何您感兴趣的指标。例如，以下代码片段记录了YOLOv5的训练损失和360个batch之后的validation mAP值：

# 训练循环
for epoch in range(start_epoch, epochs):
    ...
    for i, (imgs, targets, paths, _) in enumerate(train_dataloader):
        ...
        loss_dict = ComputeLoss(pred, targets.to(device))  # 计算loss
        loss_total = sum(loss_dict.values())  # 计算total loss
        loss_total.backward()  # 反向传播
        ...
        optimizer.step()
        optimizer.zero_grad()
        ...
        
        # 保存损失到MLflow
        mlflow.log_metric('train_loss', loss_total.item(), step=batch_i)

    # 360个批量(batch)之后运行一次validation
    if (epoch + 1) % 10 == 0:
        model.eval()
        ...
        with torch.no_grad():
            for batch_i, (imgs, targets, paths, shapes) in enumerate(val_dataloader):
                ...
                
            # 保存validation mAP到MLflow
            mlflow.log_metric('val_mAP', mAP, step=(epoch + 1) * len(train_dataloader))

在这个例子中，我们在每个batch的迭代结束时记录train loss，并在运行了360个batch之后记录validation mAP。

结束MLflow run

在train.py的末尾，您需要使用mlflow.end_run()命令来结束MLflow run。以下是一个例子：

if mlflow.active_run() is not None:
    mlflow.end_run()

当您运行train.py时，MLflow将自动记录您在代码中记录的metrics，并将其保存在指定的tracking URI下。您可以使用mlflow ui命令在本地查看metrics，例如：

mlflow ui --host 0.0.0.0 --port [port number] --backend-store-uri [ui data path]

希望这些步骤可以帮助您开始使用MLflow跟踪YOLOv5训练的metrics。

朋友你好，以下是我把你的问题和相关观点都看了一遍分析出来的，望采纳谢谢啦
不是用这句就能解决了吗？还是说你用错包，当成了TF的来用
import mlflow
在train.py中添加MLflow代码：可以在train.py文件中添加MLflow代码以记录模型的性能指标和参数设置。

yolov5 加 MLflow

内容来源与ChatGpt4及newbing和百度：

祝您问题迎刃而解

set experiment name

initialize mlflow

log parameters

other code for YOLOv5 training

log metrics

save model checkpoints

end mlflow run