写在前面： 本程序以VGG16为例，用Mindspore框架进行VGG的数据集处理、网络搭建以及训练和测试。  VGGNet是牛津大学视觉几何组(Visual Geometry Group)提出的模型，该模型在2014ImageNet图像分类与定位挑战赛 ILSVRC-2014中取得在分类任务第二，定位任务第一的优异成绩。VGGNet突出的贡献是证明了很小的卷积，通过增加网络深度可以有效提高性能。VGG很好的继承了Alexnet的衣钵同时拥有着鲜明的特点。即网络层次较深。 VGGNet模型有A-E五种结构网络，深度分别为11,11,13,16,19。其中较为典型的网络结构主要有VGG16和VGG19。  本程序使用的模型为VGG16,使用的数据集为CIFAR-10数据集。 参考博客：https://blog.csdn.net/hgnuxc_1993/article/details/115956774 参考博客：https://blog.csdn.net/weixin_43496706/article/details/10121098 参考博客：https://zhuanlan.zhihu.com/p/9100284  VGG图像分类 图像分类是最基础的计算机视觉应用，属于有监督学习类别，如给定一张图像(猫、狗、飞机、汽车等等)，判断图像所属的类别。本章将介绍使用VGG16网络对CIFAR-10数据集进行分类。  VGG网络介绍 VGGNet是牛津大学视觉几何组(Visual Geometry Group)提出的模型，该模型在2014ImageNet图像分类与定位挑战赛 ILSVRC-2014中取得在分类任务第二，定位任务第一的优异成绩。VGGNet突出的贡献是证明了很小的卷积，通过增加网络深度可以有效提高性能。VGG很好的继承了Alexnet的衣钵同时拥有着鲜明的特点。即网络层次较深。 VGGNet模型有A-E五种结构网络，深度分别为11,11,13,16,19。其中较为典型的网络结构主要有VGG16和VGG19。  VGG是Oxford的Visual Geometry Group的组提出的（大家应该能看出VGG名字的由来了）。该网络是在ILSVRC 2014上的相关工作，主要工作是证明了增加网络的深度能够在一定程度上影响网络最终的性能。VGG有两种结构，分别是VGG16和VGG19，两者并没有本质上的区别，只是网络深度不一样。  image.png  VGG16相比AlexNet的一个改进是采用连续的几个3x3的卷积核代替AlexNet中的较大卷积核（11x11，7x7，5x5）。对于给定的感受野（与输出有关的输入图片的局部大小），采用堆积的小卷积核是优于采用大的卷积核，因为多层非线性层可以增加网络深度来保证学习更复杂的模式，而且代价还比较小（参数更少）。 简单来说，在VGG中，使用了3个3x3卷积核来代替7x7卷积核，使用了2个3x3卷积核来代替5*5卷积核，这样做的主要目的是在保证具有相同感知野的条件下，提升了网络的深度，在一定程度上提升了神经网络的效果。  了解VGG网络更多详细内容，参见VGG论文。  这里使用了 download.download函数 来下载 CIFAR-10 数据集 需要预先在控制台”pip install download“ CIFAR-10数据集由60000张32x32彩色图片组成，总共有10个类别，每类6000张图片。有50000个训练样本和10000个测试样本。10个类别包含飞机、汽车、鸟类、猫、鹿、狗、青蛙、马、船和卡车。 整个数据集被分为5个训练批次和1个测试批次，每一批10000张图片。测试批次包含10000张图片，是由每一类图片随机抽取出1000张组成的集合。剩下的50000张图片每一类的图片数量都是5000张，训练批次是由剩下的50000张图片打乱顺序，然后随机分成5份，所以可能某个训练批次中10个种类的图片数量不是对等的，会出现一个类的图片数量比另一类多的情况。  会在同目录下创建一个名为datasets-cifar10-bin文件夹，然后自动将数据集下载至文件夹中。下载好之后结构如下： datasets-cifar10-bin/cifar-10-batches-bin ├── batches.meta.text ├── data_batch_1.bin ├── data_batch_2.bin ├── data_batch_3.bin ├── data_batch_4.bin ├── data_batch_5.bin ├── readme.html └── test_batch.bin !pip install download from download import download url = "http://www.cs.toronto.edu/~kriz/cifar-10-binary.tar.gz" download(url, "./datasets-cifar10-bin", kind="tar.gz")下面的部分是训练和测试数据集的构建 import mindspore as ms import numpy as np import mindspore.dataset as ds import mindspore.dataset.vision as vision from mindspore import nn, ops  data_dir = "./datasets-cifar10-bin/cifar-10-batches-bin" # 数据集根目录 batch_size = 6 # 批量大小 image_size = 32 # 训练图像空间大小 workers = 4 # 并行线程个数 num_classes = 10 # 分类数量  batch_size,image_size,workers,num_classes  利用mindspore.dataset中的函数Cifar10Dataset对CIFAR-10数据集进行处理。 该函数读取和解析CIFAR-10数据集的源文件构建数据集。 生成的数据集有两列: [image, label] 。 image 列的数据类型是uint8。label 列的数据类型是uint32。 具体说明查看API文档：https://www.mindspore.cn/docs/zh-CN/master/api_python/dataset/mindspore.dataset.Cifar10Dataset.html?highlight=cifar10dataset  dataset_dir：数据集根目录 usage：值可以为"train"或"test"，表示是构建训练集还是测试集 resize：处理后的数据集图像大小，本程序中设置为32 batch_size：批量大小 workers：并行线程个数 return：返回处理好的数据集 shuffle：shuffle=True表示需要混洗数据集，即随机在其中取数据而不是按照顺序  def create_dataset_cifar10(dataset_dir, usage, resize, batch_size, workers):     data_set = ds.Cifar10Dataset(dataset_dir=dataset_dir,                                  usage=usage,                                  num_parallel_workers=workers,                                  shuffle=True)      trans = []#需要做的变化的集合     """     对于训练集，首先进行随机裁剪和随机翻转的操作。     使用mindspore.dataset.vision.RandomCrop对输入图像进行随机区域的裁剪,大小为(32, 32)。(4, 4, 4, 4)表示在裁剪前，将在图像上下左右各填充4个像素的空白。     使用mindspore.dataset.RandomHorizontalFlip,对输入图像按50%的概率进行水平随机翻转     """     if usage == "train":         trans += [             vision.RandomCrop((32, 32), (4, 4, 4, 4)),             vision.RandomHorizontalFlip(prob=0.5)         ]      """     对数据集进行大小、规模的重组，以及归一化（帮助模型收敛）     """     trans += [         vision.Resize(resize),         vision.Rescale(1.0 / 255.0, 0.0),         vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),         vision.HWC2CHW()     ]      #对于label进行的操作     target_trans = [(lambda x: np.array([x]).astype(np.int32)[0])]      # 数据映射操作     data_set = data_set.map(         operations=trans,         input_columns='image',         num_parallel_workers=workers)      data_set = data_set.map(         operations=target_trans,         input_columns='label',         num_parallel_workers=workers)      # 批量操作     data_set = data_set.batch(batch_size)      return data_set  # 利用上面写好的那个函数，获取处理后的训练与测试数据集 dataset_train = create_dataset_cifar10(dataset_dir=data_dir,                                        usage="train",                                        resize=image_size,                                        batch_size=batch_size,                                        workers=workers) step_size_train = dataset_train.get_dataset_size() index_label_dict = dataset_train.get_class_indexing()  dataset_val = create_dataset_cifar10(dataset_dir=data_dir,                                      usage="test",                                      resize=image_size,                                      batch_size=batch_size,                                      workers=workers) step_size_val = dataset_val.get_dataset_size()  step_size_val,step_size_train,index_label_dict,dataset_train 对训练数据集进行可视化操作 import matplotlib.pyplot as plt import numpy as np  data_iter = next(dataset_train.create_dict_iterator())  images = data_iter["image"].asnumpy() labels = data_iter["label"].asnumpy() print(f"Image shape: {images.shape}, Label: {labels}")  classes = []  with open(data_dir+"/batches.meta.txt", "r") as f:     for line in f:         line = line.rstrip()         if line != '':             classes.append(line)  plt.figure() for i in range(6):     plt.subplot(2, 3, i+1)     image_trans = np.transpose(images[i], (1, 2, 0))     mean = np.array([0.4914, 0.4822, 0.4465])     std = np.array([0.2023, 0.1994, 0.2010])     image_trans = std * image_trans + mean     image_trans = np.clip(image_trans, 0, 1)     plt.title(f"{classes[labels[i]]}")     plt.imshow(image_trans)     plt.axis("off") #展示训练集的数据（标签与原图） plt.show()  构建VGG16网络 关于VGG16网络结构的介绍： 如图： image.png  1、输入224x224x3的图片，经64个3x3的卷积核作两次卷积+ReLU，卷积后的尺寸变为224x224x64  2、作max pooling（最大化池化），池化单元尺寸为2x2（效果为图像尺寸减半），池化后的尺寸变为112x112x64  3、经128个3x3的卷积核作两次卷积+ReLU，尺寸变为112x112x128  4、作2x2的max pooling池化，尺寸变为56x56x128  5、经256个3x3的卷积核作三次卷积+ReLU，尺寸变为56x56x256  6、作2x2的max pooling池化，尺寸变为28x28x256  7、经512个3x3的卷积核作三次卷积+ReLU，尺寸变为28x28x512  8、作2x2的max pooling池化，尺寸变为14x14x512  9、经512个3x3的卷积核作三次卷积+ReLU，尺寸变为14x14x512  10、作2x2的max pooling池化，尺寸变为7x7x512  11、与两层1x1x4096，一层1x1x1000进行全连接+ReLU（共三层）  12、通过softmax输出1000个预测结果(最终会取可能性最大的那个预测结果作为最终预测输出)  ATTENTION：由于本程序中使用的数据集中，每张图片的大小为32*32，因此根据这个大小对VGG网络的输入尺寸进行了微调，实际应用中，针对不同的大小，对最后一块的nn.Dense的参数进行调整即可。 VGG16网络的模型图如下 image.png  测试细节 论文在测试时，将全连接层转换为卷积层。第一个全连接层转换为7x7的卷积层，最后两个全连接层转换为1x1的卷积层。示意图如下： image.png 只是把权重的维度变换和拓展了。经过转换的网络就没有了全连接层，这样网络就可以接受任意尺寸的输入，而不是像之前之能输入固定大小的输入。  这样网络的输出是一个class score map，map的每个通道表示每个分类，map的分辨率是可变的，取决于输入图片的大小。为了获得输出的向量，需要对class score map进行spatially averaged。  class VGG16(nn.Cell):     def __init__(self):         super().__init__()         numClasses = 10         self.all_sequential = nn.SequentialCell(             nn.Conv2d(3, 64, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(64),             nn.ReLU(),             nn.Conv2d(64, 64, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(64),             nn.ReLU(),             nn.MaxPool2d(kernel_size=2, stride=2),              nn.Conv2d(64, 128, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(128),             nn.ReLU(),             nn.Conv2d(128, 128, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(128),             nn.ReLU(),             nn.MaxPool2d(kernel_size=2, stride=2),              nn.Conv2d(128, 256, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(256),             nn.ReLU(),             nn.Conv2d(256, 256, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(256),             nn.ReLU(),             nn.Conv2d(256, 256, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(256),             nn.ReLU(),             nn.MaxPool2d(kernel_size=2, stride=2),              nn.Conv2d(256, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.Conv2d(512, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.Conv2d(512, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.MaxPool2d(kernel_size=2, stride=2),              nn.Conv2d(512, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.Conv2d(512, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.Conv2d(512, 512, kernel_size=3, padding=1, pad_mode="pad"),             nn.BatchNorm2d(512),             nn.ReLU(),             nn.MaxPool2d(kernel_size=2, stride=2),              # 原始模型vgg16输入image大小是224*224，这里使用的数据集输入大小为32*32，缩小7倍             # 可以根据需要的大小来调整，比如如果输入的image大小是224*224，那么由于224/32=7，因此就把第一个nn.Dense的参数改成512*7*7，其他不变             nn.Flatten(),             nn.Dense(512*1*1, 256),             nn.ReLU(),             nn.Dropout(),             nn.Dense(256, 256),             nn.ReLU(),             nn.Dropout(),             nn.Dense(256, numClasses),         )      def construct(self, x):         x = self.all_sequential(x)         return x 这个函数主要是用来处理预训练模型的，就是如果有预训练模型参数需要在训练之前输入，就把pretrained设为True，此处由于没有预训练模型提供，因此后面在训练的时候设置的是False。 如果不需要预训练的话其实这个函数就是”model = VGG16()“然后return了model而已。 from mindspore import load_checkpoint, load_param_into_net def _vgg16(pretrained: bool = False):     model = VGG16()     "VGG16模型"     #预训练模型的下载网址     model_url = "https://download.mindspore.cn/model_zoo/official/cv/vgg/vgg16_ascend_0.5.0_cifar10_official_classification_20200715/vgg16.ckpt"     #存储路径     model_ckpt = "./LoadPretrainedModel/vgg16_0715.ckpt"      if pretrained:         download(url=model_url, path=model_ckpt)         param_dict = load_checkpoint(model_ckpt)         load_param_into_net(model, param_dict)      return model 训练过程和评估过程 import mindspore as ms # 定义VGG16网络，此处不采用预训练，即将pretrained设置为False vgg16 = _vgg16(pretrained=False)  #param.requires_grad = True表示所有参数都需要求梯度进行更新。 for param in vgg16.get_parameters():     param.requires_grad = True  # 设置训练的轮数和学习率，这里训练的轮数设置为40 num_epochs = 40 #基于余弦衰减函数计算学习率。学习率最小值为0.0001，最大值为0.0005，具体API见文档https://www.mindspore.cn/docs/zh-CN/master/api_python/nn/mindspore.nn.cosine_decay_lr.html?highlight=cosine_decay_lr lr = nn.cosine_decay_lr(min_lr=0.0001, max_lr=0.0005, total_step=step_size_train * num_epochs,                         step_per_epoch=step_size_train, decay_epoch=num_epochs) # 定义优化器和损失函数 #Adam优化器，具体可参考论文https://arxiv.org/abs/1412.6980 opt = nn.Adam(params=vgg16.trainable_params(), learning_rate=lr) # 交叉熵损失 loss_fn = nn.CrossEntropyLoss()  #前向传播，计算loss def forward_fn(inputs, targets):     logits = vgg16(inputs)     loss = loss_fn(logits, targets)     return loss  #计算梯度和loss grad_fn = ops.value_and_grad(forward_fn, None, opt.parameters)  def train_step(inputs, targets):     loss, grads = grad_fn(inputs, targets)     opt(grads)     return loss  # 实例化模型 model = ms.Model(vgg16, loss_fn, opt, metrics={"Accuracy": nn.Accuracy()})  # 创建迭代器 data_loader_train = dataset_train.create_tuple_iterator(num_epochs=num_epochs) data_loader_val = dataset_val.create_tuple_iterator(num_epochs=num_epochs)  # 最佳模型存储路径 best_acc = 0 best_ckpt_dir = "./BestCheckpoint" best_ckpt_path = "./BestCheckpoint/vgg16-best.ckpt"  import os import stat  # 开始循环训练 print("Start Training Loop ...")  for epoch in range(num_epochs):     losses = []     vgg16.set_train()      # 为每轮训练读入数据      for i, (images, labels) in enumerate(data_loader_train):         loss = train_step(images, labels)         if i%100 == 0 or i == step_size_train -1:             print('Epoch: [%3d/%3d], Steps: [%3d/%3d], Train Loss: [%5.3f]'%(                 epoch+1, num_epochs, i+1, step_size_train, loss))         losses.append(loss)      # 每个epoch结束后，验证准确率      acc = model.eval(dataset_val)['Accuracy']      print("-" * 50)     print("Epoch: [%3d/%3d], Average Train Loss: [%5.3f], Accuracy: [%5.3f]" % (         epoch+1, num_epochs, sum(losses)/len(losses), acc     ))     print("-" * 50)      if acc > best_acc:         best_acc = acc         if not os.path.exists(best_ckpt_dir):             os.mkdir(best_ckpt_dir)         if os.path.exists(best_ckpt_path):             os.chmod(best_ckpt_path, stat.S_IWRITE)#取消文件的只读属性，不然删不了             os.remove(best_ckpt_path)         ms.save_checkpoint(vgg16, best_ckpt_path)  print("=" * 80) print(f"End of validation the best Accuracy is: {best_acc: 5.3f}, "       f"save the best ckpt file in {best_ckpt_path}", flush=True)  """ 验证和评估效果并且将效果可视化 """ import matplotlib.pyplot as plt  def visualize_model(best_ckpt_path, dataset_val):     net = _vgg16(pretrained=False)     # 加载模型参数     param_dict = ms.load_checkpoint(best_ckpt_path)     ms.load_param_into_net(net, param_dict)     model = ms.Model(net)     # 加载验证集的数据进行验证     data = next(dataset_val.create_dict_iterator())     images = data["image"].asnumpy()     labels = data["label"].asnumpy()     # 预测图像类别     output = model.predict(ms.Tensor(data['image']))     pred = np.argmax(output.asnumpy(), axis=1)      # 图像分类     classes = []      with open(data_dir+"/batches.meta.txt", "r") as f:         for line in f:             line = line.rstrip()             if line != '':                 classes.append(line)      # 显示图像及图像的预测值     plt.figure()     for i in range(6):         plt.subplot(2, 3, i+1)         # 若预测正确，显示为蓝色；若预测错误，显示为红色         color = 'blue' if pred[i] == labels[i] else 'red'         plt.title('predict:{}'.format(classes[pred[i]]), color=color)         picture_show = np.transpose(images[i], (1, 2, 0))         mean = np.array([0.4914, 0.4822, 0.4465])         std = np.array([0.2023, 0.1994, 0.2010])         picture_show = std * picture_show + mean         picture_show = np.clip(picture_show, 0, 1)         plt.imshow(picture_show)         plt.axis('off')      plt.show()  # 使用测试数据集进行验证 visualize_model(best_ckpt_path=best_ckpt_path, dataset_val=dataset_val) （一大堆一大堆的结果） 另一次测试中，经过10个Epoch后准确率达到了55%，运行输出如下： Start Training Loop ...  Epoch: [ 1/ 10], Steps: [ 1/8334], Train Loss: [2.304] Epoch: [ 1/ 10], Steps: [101/8334], Train Loss: [2.298] …… Epoch: [ 1/ 10], Steps: [8301/8334], Train Loss: [2.492] Epoch: [ 1/ 10], Steps: [8334/8334], Train Loss: [1.792] Epoch: [ 1/ 10], Average Train Loss: [2.073], Accuracy: [0.190] Epoch: [ 2/ 10], Steps: [ 1/8334], Train Loss: [1.713] …… Epoch: [ 2/ 10], Steps: [8334/8334], Train Loss: [1.864] Epoch: [ 2/ 10], Average Train Loss: [1.907], Accuracy: [0.195] Epoch: [ 3/ 10], Steps: [ 1/8334], Train Loss: [1.432] …… Epoch: [ 3/ 10], Steps: [8334/8334], Train Loss: [1.967] Epoch: [ 3/ 10], Average Train Loss: [1.834], Accuracy: [0.297] Epoch: [ 4/ 10], Steps: [ 1/8334], Train Loss: [1.815] …… Epoch: [ 4/ 10], Steps: [8334/8334], Train Loss: [0.952] Epoch: [ 4/ 10], Average Train Loss: [1.680], Accuracy: [0.382] Epoch: [ 5/ 10], Steps: [ 1/8334], Train Loss: [1.300] …… Epoch: [ 5/ 10], Steps: [8334/8334], Train Loss: [2.586] Epoch: [ 5/ 10], Average Train Loss: [1.557], Accuracy: [0.395] Epoch: [ 6/ 10], Steps: [ 1/8334], Train Loss: [1.660] …… Epoch: [ 6/ 10], Steps: [8334/8334], Train Loss: [0.922] Epoch: [ 6/ 10], Average Train Loss: [1.460], Accuracy: [0.423] Epoch: [ 7/ 10], Steps: [ 1/8334], Train Loss: [1.651] …… Epoch: [ 7/ 10], Steps: [8334/8334], Train Loss: [1.811] Epoch: [ 7/ 10], Average Train Loss: [1.374], Accuracy: [0.514] Epoch: [ 8/ 10], Steps: [ 1/8334], Train Loss: [0.895] …… Epoch: [ 8/ 10], Steps: [8334/8334], Train Loss: [1.344] Epoch: [ 8/ 10], Average Train Loss: [1.296], Accuracy: [0.514] Epoch: [ 9/ 10], Steps: [ 1/8334], Train Loss: [1.672] …… Epoch: [ 9/ 10], Steps: [8334/8334], Train Loss: [0.477] Epoch: [ 9/ 10], Average Train Loss: [1.234], Accuracy: [0.512] Epoch: [ 10/ 10], Steps: [ 1/8334], Train Loss: [1.143] …… Epoch: [ 10/ 10], Steps: [8334/8334], Train Loss: [4.882] Epoch: [ 10/ 10], Average Train Loss: [1.192], Accuracy: [0.550] ================================================================================  End of validation the best Accuracy is: 0.550, save the best ckpt file in ./BestCheckpoint/resnet50-best.ckpt 

#数据加载和准备 from download import download  url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz"  download(url, "./datasets-cifar10-bin", kind="tar.gz", replace=True) #数据加载 import mindspore as ms#将MindSpore框架导入并重命名为ms，以便在代码中使用简短的别名来引用MindSpore的功能。 import mindspore.dataset as ds#入MindSpore中的数据集模块，用于处理和管理数据集。 import mindspore.dataset.vision as vision #入MindSpore中用于处理视觉数据的模块，例如图像数据的加载和预处理。 import mindspore.dataset.transforms as transforms #导入MindSpore中的数据转换模块，用于对数据集进行各种转换和处理操作，如数据增强、标准化等。 from mindspore import dtype as mstype#从MindSpore中导入数据类型（dtype）并将其重命名为mstype，用于指定张量和数组的数据类型 data_dir = "./datasets-cifar10-bin/cifar-10-batches-bin"  # 数据集根目录 batch_size = 256  # 批量大小 image_size = 32  # 训练图像空间大小 workers = 4  # 并行线程个数 num_classes = 10  # 分类数量  def create_dataset_cifar10(dataset_dir, usage, resize, batch_size, workers): #函数：定义了一个函数来创建CIFAR-10数据集，接收参数包括数据集目录、用途、图像大小、批量大小和线程数     data_set = ds.Cifar10Dataset(dataset_dir=dataset_dir,                                  usage=usage,                                  num_parallel_workers=workers,                                  shuffle=True) #使用MindSpore的Cifar10Dataset类创建CIFAR-10数据集，指定数据集目录、用途、线程数和是否打乱数据。     trans = []#定义了一个数据增强操作的列表。     if usage == "train": #如果数据集用途是训练，则执行以下操作。         trans += [        #将随机裁剪和水平翻转等操作添加到数据增强操作列表中。             vision.RandomCrop((32, 32), (4, 4, 4, 4)),             vision.RandomHorizontalFlip(prob=0.5)         ]      trans += [             #将缩放、归一化和通道转换等操作添加到数据增强操作列表中。         vision.Resize(resize),         vision.Rescale(1.0 / 255.0, 0.0),         vision.Normalize([0.4914, 0.4822, 0.4465], [0.2023, 0.1994, 0.2010]),         vision.HWC2CHW()     ]      target_trans = transforms.TypeCast(mstype.int32)   #定义一个目标数据类型转换操作，将标签转换为int32类型。      # 数据映射操作，对图像进行处理     data_set = data_set.map(operations=trans,                             input_columns='image',                             num_parallel_workers=workers)     #将数据集映射到目标数据类型转换操作上，对标签进行处理。     data_set = data_set.map(operations=target_trans,                             input_columns='label',                             num_parallel_workers=workers)      # 批量操作     data_set = data_set.batch(batch_size)      return data_set  # 获取处理后的训练与测试数据集 #使用create_dataset_cifar10函数创建训练数据集。 dataset_train = create_dataset_cifar10(dataset_dir=data_dir,                                        usage="train",                                        resize=image_size,                                        batch_size=batch_size,                                        workers=workers) #获取训练数据集的大小 step_size_train = dataset_train.get_dataset_size() #使用create_dataset_cifar10函数创建测试数据集。 dataset_val = create_dataset_cifar10(dataset_dir=data_dir,                                      usage="test",                                      resize=image_size,                                      batch_size=batch_size,                                      workers=workers) #获取验证数据集的大小，以便在模型评估阶段使用。 step_size_val = dataset_val.get_dataset_size() #对数据进行可视化 import matplotlib.pyplot as plt import numpy as np  data_iter = next(dataset_train.create_dict_iterator())  images = data_iter["image"].asnumpy() labels = data_iter["label"].asnumpy() print(f"Image shape: {images.shape}, Label shape: {labels.shape}")  # 训练数据集中，前六张图片所对应的标签 print(f"Labels: {labels[:6]}")  classes = []  with open(data_dir + "/batches.meta.txt", "r") as f:     for line in f:         line = line.rstrip()         if line:             classes.append(line)  # 训练数据集的前六张图片 plt.figure() for i in range(6):     plt.subplot(2, 3, i + 1)     image_trans = np.transpose(images[i], (1, 2, 0))#对图像数据进行转置操作，将通道维度移动到最后。     mean = np.array([0.4914, 0.4822, 0.4465])#定义图像均值     std = np.array([0.2023, 0.1994, 0.2010])#定义图像标准差     image_trans = std * image_trans + mean#对图像进行反归一化操作     image_trans = np.clip(image_trans, 0, 1)#将图像像素值限制在0到1之间     plt.title(f"{classes[labels[i]]}")#设置当前子图的标题为对应标签的类别信息     plt.imshow(image_trans)#在子图中显示处理后的图像     plt.axis("off")#关闭坐标轴显示 plt.show()#关闭坐标轴显示 #构建网络构建残差网络结构残差网络结构图如下图所示，残差网络由两个分支构成：一个主分支，一个shortcuts（图中弧线表示）。主分支通过堆叠一系列的卷积操作得到，shotcuts从输入直接到输出，主分支输出的特征矩阵𝐹(𝑥)�(�)加上shortcuts输出的特征矩阵𝑥�得到𝐹(𝑥)+𝑥�(�)+�，通过Relu激活函数后即为残差网络最后的输出。如下代码定义ResidualBlockBase类实现Building Block结构。 from typing import Type, Union, List, Optional#导入了需要用到的类型提示模块，用于指定函数参数和返回值的类型。 import mindspore.nn as nn#导入MindSpore深度学习框架中的神经网络模块nn，用于构建神经网络模型。 from mindspore.common.initializer import Normal#从MindSpore深度学习框架的初始化模块中导入了Normal类，用于参数初始化。  # 初始化卷积层与BatchNorm的参数 weight_init = Normal(mean=0, sigma=0.02)#创建一个正态分布的参数初始化对象，平均值为0，标准差为0.02 gamma_init = Normal(mean=1, sigma=0.02)#创建另一个正态分布的参数初始化对象，用于初始化BatchNorm层中的gamma参数。  class ResidualBlockBase(nn.Cell): #表示这是一个神经网络模型的组件。     expansion: int = 1  # 最后一个卷积核数量与第一个卷积核数量相等      def __init__(self, in_channel: int, out_channel: int,                  stride: int = 1, norm: Optional[nn.Cell] = None,                  down_sample: Optional[nn.Cell] = None) -> None:  #定义了初始化函数__init__，接受输入通道数in_channel、                                                                     #输出通道数out_channel、步幅stride、归一化norm和下采样down_sample等参数，并且没有返回值。         super(ResidualBlockBase, self).__init__()   #调用父类nn.Cell的初始化函数，确保正确地初始化继承的属性。         if not norm:  #根据是否传入归一化参数norm，选择是否使用BatchNorm2d归一化层             self.norm = nn.BatchNorm2d(out_channel)         else:             self.norm = norm          self.conv1 = nn.Conv2d(in_channel, out_channel,                                kernel_size=3, stride=stride,                                weight_init=weight_init)#创建一个2维卷积层conv1，指定输入通道数、                                                         #输出通道数、卷积核大小、步幅和参数初始化方式。         self.conv2 = nn.Conv2d(in_channel, out_channel,                                kernel_size=3, weight_init=weight_init)#创建另一个2维卷积层conv2，指定输入通道数、                                                                         #输出通道数、卷积核大小和参数初始化方式。         self.relu = nn.ReLU()#创建一个ReLU激活函数实例relu。         self.down_sample = down_sample #将传入的下采样函数赋值给成员变量down_sample，如果没有传入则为None。      def construct(self, x):#用于定义ResidualBlockBase的前向传播逻辑，接受输入x作为参数         """ResidualBlockBase construct."""         identity = x  # shortcuts分支          out = self.conv1(x)  # 主分支第一层：3*3卷积层  使用conv1进行卷积操作，得到输出out。         out = self.norm(out) #对输出out进行归一化操作。         out = self.relu(out) #对输出out进行ReLU激活函数操作         out = self.conv2(out)  # 主分支第二层：3*3卷积层 使用conv2进行卷积操作，得到输出out。         out = self.norm(out)   # 再次对输出out进行归一化操作          if self.down_sample is not None:  #如果存在下采样函数，对输入x进行下采样操作，并将结果赋值给identity。             identity = self.down_sample(x)         out += identity  # 输出为主分支与shortcuts之和         out = self.relu(out)  #对相加后的输出进行ReLU激活函数操作。          return out #如下代码定义ResidualBlock类实现Bottleneck结构。 class ResidualBlock(nn.Cell):#定义了一个名为ResidualBlock的类，继承自nn.Cell，表示这是一个神经网络模型的组件。     expansion = 4  # 最后一个卷积核的数量是第一个卷积核数量的4倍      def __init__(self, in_channel: int, out_channel: int,                  stride: int = 1, down_sample: Optional[nn.Cell] = None) -> None:           #定义了初始化函数__init__，         #接受输入通道数in_channel、输出通道数out_channel、步幅stride和下采样down_sample等参数，并且没有返回值。          super(ResidualBlock, self).__init__()#调用父类nn.Cell的初始化函数，确保正确地初始化继承的属性。          self.conv1 = nn.Conv2d(in_channel, out_channel,                                kernel_size=1, weight_init=weight_init)         #创建一个2维卷积层conv1，指定输入通道数in_channel、         #输出通道数out_channel、卷积核大小为1，并使用weight_init进行参数初始化。         self.norm1 = nn.BatchNorm2d(out_channel)         #创建一个BatchNorm2d归一化层norm1，指定输入通道数为out_channel。         self.conv2 = nn.Conv2d(out_channel, out_channel,                                kernel_size=3, stride=stride,                                weight_init=weight_init)         #创建一个2维卷积层conv2，指定输入通道数和输出通道数都为out_channel，         #卷积核大小为3，并且可以通过stride参数设置步幅。         self.norm2 = nn.BatchNorm2d(out_channel)         #创建一个BatchNorm2d归一化层norm2，指定输入通道数为out_channel。         self.conv3 = nn.Conv2d(out_channel, out_channel * self.expansion,                                kernel_size=1, weight_init=weight_init)         #创建一个2维卷积层conv3，指定输入通道数为out_channel，         #输出通道数为out_channel * self.expansion（即4倍），卷积核大小为1。         self.norm3 = nn.BatchNorm2d(out_channel * self.expansion)         #创建一个BatchNorm2d归一化层norm3，指定输入通道数为out_channel * self.expansion。         self.relu = nn.ReLU()#创建一个ReLU激活函数实例rel         self.down_sample = down_sample#将传入的下采样函数赋值给成员变量down_sample，如果没有传入则为None。      def construct(self, x): #定义了construct方法，用于定义ResidualBlock的前向传播逻辑，接受输入x作为参数。          identity = x  # shortscuts分支          out = self.conv1(x)  # 主分支第一层：1*1卷积层使用conv1进行卷积操作，得到输出out。         out = self.norm1(out)#对输出out进行归一化操作         out = self.relu(out)#对输出out进行ReLU激活函数操作         out = self.conv2(out)  # 主分支第二层：3*3卷积层 使用conv2进行卷积操作，得到输出out。         out = self.norm2(out)#使用conv2进行卷积操作，得到输出out。         out = self.relu(out)#对输出out进行ReLU激活函数操作。         out = self.conv3(out)  # 主分支第三层：1*1卷积层 使用conv3进行卷积操作，得到输出out。         out = self.norm3(out)#对输出out进行归一化操作。          if self.down_sample is not None:             identity = self.down_sample(x) #如果存在下采样函数，对输入x进行下采样操作，并将结果赋值给identity。          out += identity  # 输出为主分支与shortcuts之和  将主分支的输出与shortcuts分支的输出相加。         out = self.relu(out)  #对相加后的输出进行ReLU激活函数操作。          return out #构建ResNet50网络 def make_layer(last_out_channel, block: Type[Union[ResidualBlockBase, ResidualBlock]],                channel: int, block_nums: int, stride: int = 1):     ##定义了一个名为make_layer的函数，接受输入参数last_out_channel（上一层的输出通道数）、     #zzblock（残差块的类型）、channel（通道数）、block_nums（块的数量）和stride（步幅），并且没有返回值。     down_sample = None  # shortcuts分支      if stride != 1 or last_out_channel != channel * block.expansion:         #判断条件，如果步幅不为1或者上一层的输出通道数不等于channel * block.expansion，进入条件语句块。         down_sample = nn.SequentialCell([             nn.Conv2d(last_out_channel, channel * block.expansion,                       kernel_size=1, stride=stride, weight_init=weight_init),             nn.BatchNorm2d(channel * block.expansion, gamma_init=gamma_init)         ])         #如果满足条件，创建一个下采样模块down_sample，使用Conv2d和BatchNorm2d构建，用于调整维度匹配。     layers = [] #初始化一个空列表layers，用于存储构建的残差块。     layers.append(block(last_out_channel, channel, stride=stride, down_sample=down_sample))         #将第一个残差块添加到layers列表中，传入参数last_out_channel、channel、stride和down_sample。     in_channel = channel * block.expansion #计算下一层的输入通道数，用于堆叠残差网络。     # 堆叠残差网络     for _ in range(1, block_nums): #循环block_nums次，用于堆叠多个残差块。          layers.append(block(in_channel, channel)) #在循环中，将新的残差块添加到layers列表中，传入参数in_channel和channel。      return nn.SequentialCell(layers) #将layers列表中的残差块构建成一个SequentialCell，并返回作为整个层的输出。 #如下示例代码实现ResNet50模型的构建，通过用调函数resnet50即可构建ResNet50模型，函数resnet50参数如下：num_classes：分类的类别数，默认类别数为1000。pretrained：下载对应的训练模型，并加载预训练模型中的参数到网络中。 from mindspore import load_checkpoint, load_param_into_net #从MindSpore库中导入load_checkpoint和load_param_into_net函数，用于加载模型参数到网络中。   class ResNet(nn.Cell): #定义一个名为ResNet的类，继承自nn.Cell，表示这是一个神经网络模型。     def __init__(self, block: Type[Union[ResidualBlockBase, ResidualBlock]],                  layer_nums: List[int], num_classes: int, input_channel: int) -> None:           #定义ResNet类的初始化方法，接受参数block（残差块类型）、layer_nums（各层残差块数量列表）、         #num_classes（分类类别数）、input_channel（输入通道数），并且没有返回值。         super(ResNet, self).__init__() #调用父类nn.Cell的初始化方法。          self.relu = nn.ReLU()         # 第一个卷积层，输入channel为3（彩色图像），输出channel为64         self.conv1 = nn.Conv2d(3, 64, kernel_size=7, stride=2, weight_init=weight_init)         self.norm = nn.BatchNorm2d(64)         # 最大池化层，缩小图片的尺寸         self.max_pool = nn.MaxPool2d(kernel_size=3, stride=2, pad_mode='same')         #定义一个最大池化层，用于下采样特征图，参数设置为3x3的池化核，步幅为2，填充模式为'same'。         # 各个残差网络结构块定义         self.layer1 = make_layer(64, block, 64, layer_nums[0])         self.layer2 = make_layer(64 * block.expansion, block, 128, layer_nums[1], stride=2)         self.layer3 = make_layer(128 * block.expansion, block, 256, layer_nums[2], stride=2)         self.layer4 = make_layer(256 * block.expansion, block, 512, layer_nums[3], stride=2)         # 平均池化层         self.avg_pool = nn.AvgPool2d()         # flattern层         self.flatten = nn.Flatten()         # 全连接层         self.fc = nn.Dense(in_channels=input_channel, out_channels=num_classes)      def construct(self, x):  #定义了网络的构建方法construct，接受输入x作为参数。           x = self.conv1(x)         x = self.norm(x)         x = self.relu(x)         x = self.max_pool(x)          x = self.layer1(x)         x = self.layer2(x)         x = self.layer3(x)         x = self.layer4(x)          x = self.avg_pool(x)         x = self.flatten(x)         x = self.fc(x)          return x  def _resnet(model_url: str, block: Type[Union[ResidualBlockBase, ResidualBlock]],             layers: List[int], num_classes: int, pretrained: bool, pretrained_ckpt: str,             input_channel: int):     model = ResNet(block, layers, num_classes, input_channel)      if pretrained:         # 加载预训练模型         download(url=model_url, path=pretrained_ckpt, replace=True)         param_dict = load_checkpoint(pretrained_ckpt)         load_param_into_net(model, param_dict)      return model  -------------------------------------------------------------------------------------------------def resnet50(num_classes: int = 1000, pretrained: bool = False):     """ResNet50模型"""     resnet50_url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/models/application/resnet50_224_new.ckpt"     resnet50_ckpt = "./LoadPretrainedModel/resnet50_224_new.ckpt"     return _resnet(resnet50_url, ResidualBlock, [3, 4, 6, 3], num_classes,                    pretrained, resnet50_ckpt, 2048) #模型训练与评估 # 定义ResNet50网络 network = resnet50(pretrained=True)  # 全连接层输入层的大小 in_channel = network.fc.in_channels fc = nn.Dense(in_channels=in_channel, out_channels=10) # 重置全连接层 network.fc = fc  # 设置学习率 num_epochs = 5 lr = nn.cosine_decay_lr(min_lr=0.00001, max_lr=0.001, total_step=step_size_train * num_epochs,                         step_per_epoch=step_size_train, decay_epoch=num_epochs) # 定义优化器和损失函数 opt = nn.Momentum(params=network.trainable_params(), learning_rate=lr, momentum=0.9) loss_fn = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')  def forward_fn(inputs, targets):     logits = network(inputs)     loss = loss_fn(logits, targets)     return loss  grad_fn = ms.value_and_grad(forward_fn, None, opt.parameters)  def train_step(inputs, targets):     loss, grads = grad_fn(inputs, targets)     opt(grads)     return loss import os # 创建迭代器 data_loader_train = dataset_train.create_tuple_iterator(num_epochs=num_epochs) data_loader_val = dataset_val.create_tuple_iterator(num_epochs=num_epochs) # 最佳模型存储路径 best_acc = 0 best_ckpt_dir = "./BestCheckpoint" best_ckpt_path = "./BestCheckpoint/resnet50-best.ckpt" if not os.path.exists(best_ckpt_dir):     os.mkdir(best_ckpt_dir) import mindspore.ops as ops  def train(data_loader, epoch):     """模型训练"""     losses = []     network.set_train(True)      for i, (images, labels) in enumerate(data_loader):         loss = train_step(images, labels)         if i % 100 == 0 or i == step_size_train - 1:             print('Epoch: [%3d/%3d], Steps: [%3d/%3d], Train Loss: [%5.3f]' %                   (epoch + 1, num_epochs, i + 1, step_size_train, loss))         losses.append(loss)      return sum(losses) / len(losses)  def evaluate(data_loader):     """模型验证"""     network.set_train(False)      correct_num = 0.0  # 预测正确个数     total_num = 0.0  # 预测总数      for images, labels in data_loader:         logits = network(images)         pred = logits.argmax(axis=1)  # 预测结果         correct = ops.equal(pred, labels).reshape((-1, ))         correct_num += correct.sum().asnumpy()         total_num += correct.shape[0]      acc = correct_num / total_num  # 准确率      return acc  # 开始循环训练 print("Start Training Loop ...")  for epoch in range(num_epochs):     curr_loss = train(data_loader_train, epoch)     curr_acc = evaluate(data_loader_val)      print("-" * 50)     print("Epoch: [%3d/%3d], Average Train Loss: [%5.3f], Accuracy: [%5.3f]" % (         epoch+1, num_epochs, curr_loss, curr_acc     ))     print("-" * 50)      # 保存当前预测准确率最高的模型     if curr_acc > best_acc:         best_acc = curr_acc         ms.save_checkpoint(network, best_ckpt_path)  print("=" * 80) print(f"End of validation the best Accuracy is: {best_acc: 5.3f}, "       f"save the best ckpt file in {best_ckpt_path}", flush=True) #可视化模型预测 import matplotlib.pyplot as plt  def visualize_model(best_ckpt_path, dataset_val):     num_class = 10  # 对狼和狗图像进行二分类     net = resnet50(num_class)     # 加载模型参数     param_dict = ms.load_checkpoint(best_ckpt_path)     ms.load_param_into_net(net, param_dict)     # 加载验证集的数据进行验证     data = next(dataset_val.create_dict_iterator())     images = data["image"]     labels = data["label"]     # 预测图像类别     output = net(data['image'])     pred = np.argmax(output.asnumpy(), axis=1)      # 图像分类     classes = []      with open(data_dir + "/batches.meta.txt", "r") as f:         for line in f:             line = line.rstrip()             if line:                 classes.append(line)      # 显示图像及图像的预测值     plt.figure()     for i in range(6):         plt.subplot(2, 3, i + 1)         # 若预测正确，显示为蓝色；若预测错误，显示为红色         color = 'blue' if pred[i] == labels.asnumpy()[i] else 'red'         plt.title('predict:{}'.format(classes[pred[i]]), color=color)         picture_show = np.transpose(images.asnumpy()[i], (1, 2, 0))         mean = np.array([0.4914, 0.4822, 0.4465])         std = np.array([0.2023, 0.1994, 0.2010])         picture_show = std * picture_show + mean         picture_show = np.clip(picture_show, 0, 1)         plt.imshow(picture_show)         plt.axis('off')      plt.show()  # 使用测试数据集进行验证 visualize_model(best_ckpt_path=best_ckpt_path, dataset_val=dataset_val) 

我是用ATC生成AscendP3的模型可用，命令如下：atc --framework=5 --model=./fairmot.onnx --input_format=NCHW --input_shape="actual_input_1:1,3,2048,512" --output=./fairmot_bs1 --log=error --soc_version=Ascend310P3在300I上正确推理，同样的模型，用：atc --framework=5 --model=./fairmot.onnx --input_format=NCHW --input_shape="actual_input_1:1,3,2048,512" --output=./fairmot_bs1_B4 --log=error --soc_version=Ascend310B4生成ascend310B4在200 DK上报错，报错内容如下：(FairMot) HwHiAiUser@davinci-mini:~/altas/project/FairMOT/test$ python3 -m ais_bench --model fairmot_bs1_B4.om --input ./pre_dataset/ --output ./out --output_dirname result --outfmt BIN[INFO] acl init success[INFO] open device 0 successE19999: Inner Error!Get stub function failed, name=1351718655777264385_trans_Cast_0.[FUNC:GetFunctionByName][FILE:logger.cc][LINE:91]rtGetFunctionByName execute failed, reason=[kernel lookup error][FUNC:FuncErrorReason][FILE:error_message_manage.cc][LINE:50]E19999 Call rtGetFunctionByName failed op:trans_Cast_0(Cast), bin_file_key:1351718655777264385_trans_Cast_0, ret:0x7BC93[FUNC:InitTVMTask][FILE:kernel_task_info.cc][LINE:1167]TraceBack (most recent call last):Task index:1 init failed, ret:507027.[FUNC:InitTaskInfo][FILE:davinci_model.cc][LINE:3818][Model][FromData]load model from data failed, ge result[507027][FUNC:ReportCallError][FILE:log_inner.cpp][LINE:161][ERROR] load model from file failed, model file is fairmot_bs1_B4.om[WARN] Check failed:processModel->LoadModelFromFile(modelPath), ret:1[WARN] no model had been loaded, unload failedTraceback (most recent call last):File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/runpy.py", line 193, in _run_module_as_main"__main__", mod_spec)File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/runpy.py", line 85, in _run_codeexec(code, run_globals)File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/site-packages/ais_bench/__main__.py", line 18, inexec(open(os.path.join(cur_path, "infer/__main__.py")).read())File "", line 280, inFile "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/site-packages/ais_bench/infer/infer_process.py", line 752, in infer_processmain(args)File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/site-packages/ais_bench/infer/infer_process.py", line 428, in mainsession = init_inference_session(args, tmp_acl_json_path if tmp_acl_json_path is not None else acl_json_path)File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/site-packages/ais_bench/infer/infer_process.py", line 115, in init_inference_sessionsession = InferSession(args.device, args.model, acl_json_path, args.debug, args.loop)File "/home/HwHiAiUser/.conda/envs/FairMot/lib/python3.7/site-packages/ais_bench/infer/interface.py", line 94, in __init__self.session = aclruntime.InferenceSession(self.model_path, self.device_id, self.options)RuntimeError: [1][ACL: invalid parameter][INFO] end to reset device 0[INFO] end to finalize acl文件信息如下：(FairMot) HwHiAiUser@davinci-mini:~/altas/project/FairMOT/test$ ls -ltotal 123140-r--r--r-- 1 HwHiAiUser HwHiAiUser 41906916 Mar 1 20:33 fairmot_bs1.om-r--r--r-- 1 HwHiAiUser HwHiAiUser 42070773 Mar 1 20:33 fairmot_bs1_B1.om-r--r--r-- 1 HwHiAiUser HwHiAiUser 42071677 Mar 2 21:58 fairmot_bs1_B4.om-rw-rw-r-- 1 HwHiAiUser HwHiAiUser 5412 Mar 1 20:31 fairmot_postprocess.pydrwx------ 2 HwHiAiUser HwHiAiUser 4096 Mar 3 21:49 outdr-xr-xr-x 2 HwHiAiUser HwHiAiUser 4096 Mar 1 20:31 pre_dataset-rw-rw-r-- 1 HwHiAiUser HwHiAiUser 8970 Mar 1 20:31 test.py系统报507027错误，可能是什么原因？模型太大？

我们自己写了一个unet模型的程序，怎么将它弄到atlas200DK开发板上跑啊，已经完成了制卡，修改ip地址的步骤了。谢谢各位大神了

我使用https://gitee.com/ascend/ModelZoo-PyTorch/tree/master/ACL_PyTorch/contrib/cv/detection/FairMOT时，严格按照readme文件操作，前面全部成功，最后运行：python3 fairmot_postprocess.py --data_dir=./dataset  --input_root=/home/HwHiAiUser/test/out/result 时，报错：Fix size testing. training chunk_sizes: [6, 6] The output will be saved to  ./FairMOT/src/lib/../../exp/mot/default heads {'hm': 1, 'wh': 4, 'id': 128, 'reg': 2} 2024-02-16 16:10:09 [INFO]: start seq: MOT17-02-SDP 2024-02-16 16:10:09 [INFO]: start seq: MOT17-02-SDP Traceback (most recent call last):   File "fairmot_postprocess.py", line 153, in <module>     save_videos=False)   File "fairmot_postprocess.py", line 66, in process     nf, ta, tc = eval_seq(opt, dataloader, data_type, result_filename, seq,save_dir=output_dir, show_image=show_image, frame_rate=frame_rate)   File "fairmot_postprocess.py", line 104, in eval_seq     hm_eval = torch.from_numpy(np.fromfile(dataloader[i + 3], dtype='float32').reshape(1, 1, 152, 272)) ValueError: cannot reshape array of size 82688 into shape (1,1,152,272) 请问为什么？如何解决？我的环境，ubuntu20.04 kernel：5.4.0-26-generic  ；Ascend310P3；torch 1.5；python 3.7

前言基于java使用SDK实现图像识别，主要以媒资图像标签和名人识别为例。一、环境配置Maven（没有直接下载华为的SDK包，而是使用Maven安装依赖）JDK19（官方的SDK包要求JDK版本必须高于JDK8版本，大家根据自己只要满足版本要求即可）开发工具：IDEA 2023.3（其他版本也可）能创建Maven项目即可开通图像识别服务（目前是免费体验）：这里我开通的是图像标签/媒资图像标签和名人识别服务。设置访问密钥服务区域：我开通的服务区域是华北-北京四关键步骤Maven项目的创建和Java环境变量的配置我就不再赘诉，这是大家学习java早已熟练掌握的，这里只讲诉易错的。开通图像识别服务 华为云首页就有云产品体验区（找不到就在搜索栏检索），勾选AI： 点击“立即体验”后，找到服务列表，开通你想要的服务（点击开通）： 设置访问密钥 在控制台找到“我的凭证”： 找到“访问密钥”，如果没有就新增，新增后一定要下载密钥的CSV文件，他会有提示让你下载，防止你忘记： 下载完csv文件后用记事本打开即可看到AK和SK： Maven引入依赖配置 版本可以自己切换 <dependency> <groupId>com.huaweicloud.sdk</groupId> <artifactId>huaweicloud-sdk-image</artifactId> <version>3.1.8</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.70</version> </dependency> <dependency> <groupId>org.apache.httpcomponents</groupId> <artifactId>httpcore</artifactId> <version>4.4.16</version> </dependency> <dependency> <groupId>commons-codec</groupId> <artifactId>commons-codec</artifactId> <version>1.16.0</version> </dependency> <dependency> <groupId>commons-io</groupId> <artifactId>commons-io</artifactId> <version>2.13.0</version> </dependency>二、图像识别实例媒资图像标签功能介绍：对用户传入的图像可以返回图像中的物体名称、所属类别及置信度信息。使用图片是网上的，仅作学习使用： 代码如下：/** * @Version: 1.0.0 * @Author: Dragon_王 * @ClassName: RunImageMediaTaggingSolution * @Description: 媒资图像标签 * @Date: 2024/1/8 11:51 */ /** * 此demo仅供测试使用，强烈建议使用SDK * 使用前需配置依赖jar包。jar包可通过下载SDK获取 */ import com.huaweicloud.sdk.core.auth.ICredential; import com.huaweicloud.sdk.core.auth.BasicCredentials; import com.huaweicloud.sdk.core.exception.ConnectionException; import com.huaweicloud.sdk.core.exception.RequestTimeoutException; import com.huaweicloud.sdk.core.exception.ServiceResponseException; import com.huaweicloud.sdk.image.v2.region.ImageRegion; import com.huaweicloud.sdk.image.v2.*; import com.huaweicloud.sdk.image.v2.model.*; public class RunImageMediaTaggingSolution { public static void main(String[] args) { //此处需要输入您的AK/SK信息 String ak = "你的AK"; String sk = "你的SK"; ICredential auth = new BasicCredentials() .withAk(ak) .withSk(sk); ImageClient client = ImageClient.newBuilder() .withCredential(auth) .withRegion(ImageRegion.valueOf("cn-north-4")) //此处替换为您开通服务的区域 .build(); RunImageMediaTaggingRequest request = new RunImageMediaTaggingRequest(); ImageMediaTaggingReq body = new ImageMediaTaggingReq(); body.withThreshold(10f); body.withLanguage("zh"); body.withUrl("https://tse2-mm.cn.bing.net/th/id/OIP-C.SIuEnb1-arhtDNqfdICVqAHaE7?rs=1&pid=ImgDetMain"); //此处替换为公网可以访问的图片地址 request.withBody(body); try { RunImageMediaTaggingResponse response = client.runImageMediaTagging(request); System.out.println(response.toString()); } catch (ConnectionException e) { e.printStackTrace(); } catch (RequestTimeoutException e) { e.printStackTrace(); } catch (ServiceResponseException e) { e.printStackTrace(); System.out.println(e.getHttpStatusCode()); System.out.println(e.getErrorCode()); System.out.println(e.getErrorMsg()); } } }运行结果： //运行结果如下 class RunImageMediaTaggingResponse { result: class ImageMediaTaggingResponseResult { tags: [class ImageMediaTaggingItemBody { confidence: 83.63 type: 动物 tag: 金毛犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 金毛犬 en: Golden retriever } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 81.78 type: 动物 tag: 金毛 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 金毛 en: Golden hair } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 77.00 type: 动物 tag: 金毛寻猎犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 金毛寻猎犬 en: Golden Retriever } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 62.60 type: 动物 tag: 贵妇犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 贵妇犬 en: Poodle } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 59.02 type: 生活 tag: 狗链 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 狗链 en: Dog chain } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 生活 en: Life } instances: [] }, class ImageMediaTaggingItemBody { confidence: 53.84 type: 动物 tag: 宠物狗 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 宠物狗 en: Pet dog } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 48.01 type: 动物 tag: 狗狗 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 狗狗 en: Dog } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 44.02 type: 动物 tag: 犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 犬 en: Dog } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 42.11 type: 动物 tag: 纯种犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 纯种犬 en: Purebred dog } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }, class ImageMediaTaggingItemBody { confidence: 38.65 type: 动物 tag: 中华田园犬 i18nTag: class ImageMediaTaggingItemBodyI18nTag { zh: 中华田园犬 en: Chinese pastoral dog } i18nType: class ImageMediaTaggingItemBodyI18nType { zh: 动物 en: Animal } instances: [] }] } } Process finished with exit code 0名人识别功能介绍:分析并识别图片中包含的敏感人物、明星及网红人物，返回人物信息及人脸坐标。使用照片是网上的照片，仅作学习使用： 代码如下：/** * @Version: 1.0.0 * @Author: Dragon_王 * @ClassName: RunCelebrityRecognitionSolution * @Description: 媒资标签 * @Date: 2024/1/9 16:23 */ import com.alibaba.fastjson.JSON; import com.huaweicloud.sdk.core.auth.ICredential; import com.huaweicloud.sdk.core.auth.BasicCredentials; import com.huaweicloud.sdk.core.exception.ConnectionException; import com.huaweicloud.sdk.core.exception.RequestTimeoutException; import com.huaweicloud.sdk.core.exception.ServiceResponseException; import com.huaweicloud.sdk.image.v2.ImageClient; import com.huaweicloud.sdk.image.v2.model.RunCelebrityRecognitionRequest; import com.huaweicloud.sdk.image.v2.region.ImageRegion; import com.huaweicloud.sdk.image.v2.model.CelebrityRecognitionReq; import com.huaweicloud.sdk.image.v2.model.RunCelebrityRecognitionResponse; public class RunCelebrityRecognitionSolution { public static void main(String[] args) { // 认证用的ak和sk硬编码到代码中或者明文存储都有很大的安全风险，建议在配置文件或者环境变量中密文存放，使用时解密，确保安全 // 本示例以ak和sk保存在环境变量中来实现身份验证为例，运行本示例前请先在本地环境中设置环境变量HUAWEICLOUD_SDK_AK和HUAWEICLOUD_SDK_SK String ak = "你的AK"; String sk = "你的SK"; ICredential auth = new BasicCredentials() .withAk(ak) .withSk(sk); ImageClient client = ImageClient.newBuilder() .withCredential(auth) .withRegion(ImageRegion.valueOf("cn-north-4")) //此处替换为您开通服务的区域 .build(); RunCelebrityRecognitionRequest request = new RunCelebrityRecognitionRequest(); CelebrityRecognitionReq body = new CelebrityRecognitionReq(); body.withThreshold(0f); body.withUrl("https://tse1-mm.cn.bing.net/th/id/OIP-C.tM6jifW1xaCDP7Kia9QiYwHaKD?rs=1&pid=ImgDetMain"); //此处替换为公网可以访问的图片地址 request.withBody(body); try { RunCelebrityRecognitionResponse response = client.runCelebrityRecognition(request); System.out.println(response.getHttpStatusCode()); System.out.println(JSON.toJSONString(response)); } catch (ConnectionException e) { e.printStackTrace(); } catch (RequestTimeoutException e) { e.printStackTrace(); } catch (ServiceResponseException e) { e.printStackTrace(); System.out.println(e.getHttpStatusCode()); System.out.println(e.getErrorCode()); System.out.println(e.getErrorMsg()); } } }运行结果：200 {"httpStatusCode":200,"result":[{"confidence":0.9985551,"faceDetail":{"w":132,"h":186,"x":197,"y":79},"label":"成龙"}]} Process finished with exit code 0总结以上就是华为云的AI图像识别服务调用，这里提供官方文档

自己搭yolov5环境训练再转wk也太麻烦了吧，看文档说是有个这么个平台能在线训练和转换模型，结果哪儿哪儿找不到网址，请问网址是多少???

一、实验名称K-Means鸢尾花聚类实验二、实验目的实践所涉及并要求掌握的知识点1. 了解聚类算法和K-Means的基本概念；2. 了解如何使用MindSpore进行K-Means聚类实验。三、实验内容实验环境要求1. MindSpore 1.32. 华为云ModelArts3. PC 64bit具体实践内容使用MindSpore实现了对鸢尾花数据集做聚类分析，k-Means算法使用简单的迭代将数据集聚成k个类。四、实验原理实践所涉及的原理1. K-Means算法的过程（1）首先输入K的值，即我们希望将数据集经过聚类得到K个分组；（2）从数据集中随机选择K个数据点作为初始数据（质心，Centroid）也可选择非样本点；（3）对集合中每一个样本，分别计算其与K个质心的距离（这里的距离一般取欧氏距离或余弦距离），找到离该点最近的质心，将它归属到对应的簇；（4）所有点都归属到簇之后，M个样本就分为了K个簇，之后重新计算每个簇的质心（平均距离中心），将其定为新的质心；（5）如果新质心和老质心之间的距离小于某一个设置的阈值（表示重新计算的质心的位置变化不大，趋于稳定，或者说收敛），可以认为我们进行的聚类已经达到期望的结果，算法终止；（6）如果新质心和老质心距离变化很大，需要迭代3~5步骤。2. K-Means的主要优点（1）原理比较简单，实现也是很容易，收敛速度快。（2）聚类效果较优。（3）算法的可解释度比较强。（4）主要需要调参的参数仅仅是簇数k。3. K-Means的主要缺点（1）K值的选取不好把握；（2）对于不是凸的数据集比较难收敛；（3）如果各隐含类别的数据不平衡，比如各隐含类别的数据量严重失衡，或者各隐含类别的方差不同，则聚类效果不佳；（4）采用迭代方法，得到的结果只是局部最优；（5）对噪音和异常点比较的敏感。五、实验过程详细记录实践过程，包括涉及到的已知或输入、代码内容、结果或输出、具体步骤、遇到的问题及解决方法等1. 数据准备（1）下载数据从Iris数据集官网下载，解压后得到iris.data文件；鸢尾花数据集的形式如下图所示，包含4个特征和1个类别。（2）下载main.py文件打开新建的Notrbook实验环境，选择MindSpore；点击上传标志将刚才保存的iris.data文件上传2. 创建OBS桶（1）创建桶->配置（2）新建文件夹->创建对象（上传具体文件）3. 创建训练作业（1）新建pip-requirements.txt文件，并在桶中添加该文件（2）配置（旧版界面）（新版界面）4. 点击提交开始训练5. Notebook实现（1）在创建的Notebook中上传main.py和pip-requirements.txt（2）选择Launcher，然后选择mindsport得到新的Untitled.ipynb（3）执行pip install seaborn，指定依赖包的包名及版本号（4）重启内核，执行run main.py执行结果如下：六、心得体会       该pdf文档读起来有点困难，一开始觉得逻辑有点混乱，桶和训练作业没有理清逻辑关系。main.py里面的参数配置也比较不确定是文件路径还是url，也有一定原因是对python语言不太熟悉。最后训练作业时一直在排队，最后在同学的账户上进行相同的实验操作后运行完成了。在使用自己的账户时，在等待的过程中，利用Notebook开发环境下完成了该实验，根据打印信息得知该实验成功完成。通过本实验，对 K-means 算法有了进一步的认识（1）K-means 算法基本原理：K-means 是一种无监督学习算法，旨在将数据集划分为 K 个不同的组（簇），其中每个数据点属于与其最近的簇的中心。该算法的主要步骤包括选择初始质心、将数据点分配到最近的质心所属的簇、更新簇的中心，然后重复这些步骤直到收敛。（2）选择 K 的重要性在 K-means 算法中，选择正确的 K（簇的数量）很关键。通过实验尝试不同的 K 值，比较聚类效果，选择使得簇内相似度高、簇间相似度低的 K 值。

怎么识别该类图像验证码??

美食识别————灌汤包、柿子饼

基于华为云ModelArts实现垃圾分类一、项目背景为保护环境和节约资源，国家推出垃圾分类相关政策，但目前人工进行垃圾分类仍存在很多困难，本项目是想利用华为云自动学习来实现垃圾分类。华为云自动学习华为云自动学习是帮助人们实现AI应用的低门槛、高灵活、零代码的定制化模型开发工具。自动学习功能根据标注数据自动设计模型、自动调参、自动训练、自动压缩和部署模型。开发者无需专业的开发基础和编码能力,只需上传数据,通过自动学习界面引导和简单操作即可完成模型训练和部署。运用华为云的自动学习技术针对图像分类的定制开发，可以实现垃圾分类。二、项目步骤1. 开发环境准备（1）完成华为云账号的注册，并添加凭证密钥后可准备进行下一步的开发（2）创建ModelArts图像分类项目（3）创建OBS桶，并在这个桶中创建输入输出两个文件夹（4）申请数据集资源2. 数据标注（1）上传上述获取的数据集资源，这个数据集资源中包含两个图片，一个是训练集，一个是测试集（2）训练集当中包含多种垃圾，根据不同垃圾类型对图片完成标注，如“一次性快餐盒-其他垃圾”，“易拉罐-可回收物”等（3）完成标注后即可开始自动训练（4）自动训练完成后可部署得到一个在线服务，上传测试训练集，点击预测进行预测（5）完成实验项目之后删除自动学习项目和OBS在线资源即可

如何将H264的视频进行实施图像识别

基于华为云ModelArts实现垃圾分类小项目项目目标基于ModelArts实现一个简单的垃圾分类项目, 该项目是图像分类下任务子类。ModelArts自动学习是帮助人们实现AI应用的低门槛、高灵活、零代码的定制化模型开发工具。自动学习功能根据标注数据自动设计模型、自动调参、自动训练、自动压缩和部署模型。开发者无需专业的开发基础和编码能力，只需上传数据，通过自动学习界面引导和简单操作即可完成模型训练和部署。数据集准备数据集为华为云AI Gallery上提供的数据集该数据集包含8类生活垃圾图片，分别为：厨余垃圾蛋壳、厨余垃圾水果果皮、可回收物塑料玩具、可回收物纸板箱、其他垃圾烟蒂、其他垃圾一次性餐盒、有害垃圾干电池、有害垃圾过期药物，每类图片100张数据集下载参考链接: 下载链接项目流程创建项目进入ModelArts以后点击创建项目 选择创建图像分类项目 数据标注通过ModelArts可对图片进行一键式批量添加标签，快速完成对图片的标注操作，也可以对已标注图片修改或删除标签进行重新标注 标注完毕之后。点击开始训练。则进入训练阶段模型训练点击下一步进入训练界面。点击提交 部署上线所谓部署上线，就是预测我们的模型。上一步把训练好的模型，进行预测 部署完毕之后，点击上传图片，点击预测。右侧是预测的结果 项目总结总的来说, 华为云ModelArts训练出来的垃圾分类模型是很棒的，六个字总结就是: 高效，快捷，省心

曾拿过这类比赛奖项，做过硬件Ascend一些项目，能够结合起来，来的加

这个训练一直报错，说什么调整输入输出函数