【MindSpore】简单使用Resnet50实现狗狼图片分类。附全部代码下载。

本文章用的例子来自MindSpore官网教程 ，这里主要是分享一下个人理解和整合一下相关代码。

个人博客网站查看
环境配置：

• windows10
• MindSpore1.6.1 CPU版本
• python3.9.0

一、数据集和预训练模型下载

数据集下载

预训练模型下载

注：以上链接均来源MindSpore官网。

二、定义命令行参数并保存成config.yml

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

    parser.add_argument("--name", default="resnet50_classify", help="The name of project.")

    parser.add_argument('--dataset', default='Canidae', help='dataset name')
    parser.add_argument("--epochs", default=200, type=int, metavar='N')
    parser.add_argument('--batch_size', default=16, type=int, metavar='N')

    parser.add_argument('--pre_ckpt', default="./pre_ckpt/resnet50.ckpt")

    parser.add_argument("--delfc_flag", default=True)

    parser.add_argument('--input_channels', default=3, type=int, help='input channels')

    parser.add_argument('--num_classes', default=20, type=int, help='number of classes')

    parser.add_argument('--image_size', default=128, type=int, help='image size')

    parser.add_argument('--optimizer', default='Adam')

    parser.add_argument('--loss', default='SoftmaxCrossEntropyWithLogits')

    parser.add_argument('--dataset_sink_mode', default=False)

    config = parser.parse_args()
    return config

使用 argparse这个库可以自定义命令行参数，方便训练参数的更改。后面可以把这些参数存储为 config.yml，作为配置文件使用，也方便自己或其他人了解这个网络的相关参数。

def main():

    config = vars(parse_args())

    if config["name"] is None:
        config['name'] = "test"
    os.makedirs(os.path.join("models", config["name"]), exist_ok=True)

    config_path = 'models/%s/config.yml' % config['name']
    with open(config_path, 'w') as f:
        yaml.dump(config, f)

三、★数据集预处理和加载★

数据集分为训练集和验证集。

MindSpore提供了 mindspore.dataset.ImageFolderDataset函数可以方便读取数据集。函数官方解释

不过要使用函数需要按照规定的方式存储数据。以本数据集为例，数据集可以以下面这种方式存放。

└─Canidae
  └─train
  │   └─dogs
  │   └─wolves
  └─val
      └─dogs
      └─wolves

该数据的存放方式是，在单个目录下创建要分类图片的对应文件夹，每一个文件夹对应一个类别。

例如，该函数会自动读取train目录下的所有文件夹，将同一个文件夹内的所有图片看作同一个类别。

在按文件夹名称顺序读入图片后会给每一类的图片赋予数字标签也就是label。第一个读入的文件夹图片被记为0，第二个读入的文件夹图片被记为1，依此类推直到所有文件夹读取完毕。

这种读取方式是函数默认的方式，但这种方式可能会让人无法准确判断哪一种类别对应着哪个label，在后面进行测试推理的时候可能会麻烦一点。因此我们可以使用该函数的 class_indexing参数，用来直接指定文件夹与label的对应关系。

可以给这个参数传入字典类型。字典的键就是文件夹名称，值就是对应的数字。

例如：

dataset = ds.ImageFolderDataset(dataset_dir=image_folder_dataset_dir,
                                class_indexing={"dogs":0, "wolves":1})

这样就直接指定dogs是0，wolves是1。这就比较清晰label和类别的具体关系了。

因此我比较推荐直接将类别的名称作为文件夹的名字，可以通过函数读取文件夹的名字然后依次赋值生成相关字典并将内容保存到config文件中，这样之后测试就可以很清晰的知道类别和label关系。

def getClasses(data_path, config_path):
"""
    加载路径下所有文件夹的名字然后进行升序排序。
    将第一个文件夹记作0，第二个文件夹记作1，依此类推。
    然后将文件夹名称和对应的标记写入config文件，用于制作数据集label。
    Args:
        data_path (str): 数据集路径
        config_path (str): 配置文件路径
    Returns:
        _type_: _description_
"""
    res_dict = {"classes":{}}
    data_list = os.listdir(data_path)
    data_list.sort()
    for data in data_list:
        res_dict["classes"][data] = data_list.index(data)

    with open(config_path, 'a+') as f:
        yaml.dump(res_dict, f, Dumper=yaml.RoundTripDumper)
        f.close()
    return res_dict["classes"]

classesDict = getClasses(train_data_path, config_path)

在官方教程中给了 create_dataset函数。这个函数是比较完整的数据集读取和处理。这个函数我就不多介绍了，能说的都写在下面的注释里了。

需要注意的是 training参数。这个参数在True的时候是表示对训练集进行处理，False是对验证集进行处理。也就是只对训练集进行数据增强而验证集不用。

def create_dataset(data_path, image_size, classDict=None, batch_size=24, repeat_num=1, training=True):
    """定义数据集"""

    data_set = ds.ImageFolderDataset(data_path,
                                     num_parallel_workers=8,
                                     shuffle=True,
                                     class_indexing=classDict)

    mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]
    std = [0.229 * 255, 0.224 * 255, 0.225 * 255]
    if training:
        trans = [

            CV.RandomCropDecodeResize(image_size, scale=(0.8, 1.0), ratio=(0.75, 1.333)),

            CV.RandomHorizontalFlip(prob=0.5),

            CV.RandomRotation(90),

            CV.Normalize(mean=mean, std=std),

            CV.HWC2CHW()
        ]
    else:
        trans = [

            CV.Decode(),

            CV.Resize((image_size, image_size)),
            CV.Normalize(mean=mean, std=std),
            CV.HWC2CHW()
        ]
    type_cast_op = C.TypeCast(mstype.int32)

    data_set = data_set.map(operations=trans, input_columns="image", num_parallel_workers=8)
    data_set = data_set.map(operations=type_cast_op, input_columns="label", num_parallel_workers=8)
    data_set = data_set.batch(batch_size, drop_remainder=True)
    data_set = data_set.repeat(repeat_num)

    return data_set

四、训练过程

主要的参数配置记录和数据集加载已经说完了，模型加载和训练方面MindSpore整合的很好，只需要几句话就可以调用，所以这部分就不多说了，在文章末尾会有工程的全部文件供下载。

五、测试过程

首先要加载分类标签，就是之前保存在config文件中的内容。

还需要将字典内容的键值调换顺序，方便后面根据预测结果直接输出类别名称。

classesDict = config["classes"]

class_name = dict(zip(classesDict.values(), classesDict.keys()))

★加载测试数据及预处理★

这一部分是很关键的。这一步的加载数据选择了与之前训练时不同的方式，是使用自定义的加载方式来读取数据集。

class testDataset:
"""
    自定义的读取图片的类。
    只用于test使用，不返回label。
    返回：
    第一个值为用于分类的图
    第二个值为该图的ID，即名字和后缀
    第三个值为用于显示的图
"""
    def __init__(self, data_path):
        self.data_path = data_path
        self.imgList = os.listdir(self.data_path)

    def __getitem__(self, index):
        imgID = self.imgList[index]
        img = cv2.imread(os.path.join(self.data_path, imgID))

        img = cv2.resize(img, (256, 256))
        img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
        img = img.astype(np.float32)
        return img, imgID, img

    def __len__(self):
        return len(self.imgList)

testData = testDataset(test_data_path)

dataset = ds.GeneratorDataset(testData, ["image", "imgID", "imageInit"])

mean = [0.485 * 255, 0.456 * 255, 0.406 * 255]
std = [0.229 * 255, 0.224 * 255, 0.225 * 255]
dataset = dataset.map(operations=[CV.Normalize(mean=mean, std=std), CV.HWC2CHW()],
                      input_columns="image",
                      num_parallel_workers=8)

这一部分可能比较难理解。

首先自己定义了一个 testDataset类去读取数据集并做简单的预处理，这个类的 __getitem__函数返回三个值，分别是img，imgID，img。这三个值代表什么含义我在类的介绍里写了，可以去理解一下。

ds.GeneratorDataset这个函数可以创建一个 dataset。第一个参数就填写之前写的 testDataset类的实例结果，第二个参数填写"列名称"。这个"列名称"也就是 column_names参数，我认为可以理解为通道名称。之前 testDataset类的 __getitem__函数可以返回三个值，这三个值可以通过 ds.GeneratorDataset函数赋予每个值一个单独的名称，之后就可以通过这个"名称"调用对应的数据。

这部分可能难理解，我说的可能也不够详细和简洁，所以建议这部分单步调试，一点一点搞懂这个几个函数的用法比较好。

之后就是对图像进行归一化和通道数改变顺序的基本操作。

预测过程

pred_list = []

img_list = []

imgID_list = []

expand = ExpandDims()
for data in dataset.create_dict_iterator():

    img_list.append(data["imageInit"].asnumpy())
    imgID_list.append(str(data["imgID"]))

    image = data["image"].asnumpy()

    img = expand(Tensor(image), 0)
    output = model.predict(img)
    pred = np.argmax(output.asnumpy(), axis=1)[0]
    pred_list.append(pred)

我这里的预测没有使用batch_size的格式，而是一张一张图片的预测，所以需要进行一个扩维的操作。

如果是batch_size格式的话需要在这之前对数据集进行batch处理。

模型最后的输出也就是pred是数字，这个数字与数据集的种类对应。具体的对应关系可以从class_name字典中获得。

plt.figure(figsize=(12, 5))

for i in range(len(img_list)):
    plt.subplot(3, 9, i+1)
    plt.title('{}'.format(class_name[pred_list[i]]))
    picture_show = img_list[i]/np.amax(img_list[i])
    picture_show = np.clip(picture_show, 0, 1)
    plt.imshow(picture_show)
    plt.axis('off')
plt.show()

可视化输出。可以显示预测结果和对应图片。

注意，这里显示的图片来自 imageInit通道，因为 image通道的图片都被归一化和通道顺序转换了所以没法直接用来显示。

可视化效果：

六、完整代码下载

Github下载

CSDN下载

Original: https://blog.csdn.net/ZhuanShangNiDeXin/article/details/124206442
Author: 闪电丶教主
Title: 【MindSpore】简单使用Resnet50实现狗狼图片分类。附全部代码下载。

相关阅读1

Title: Debiased Contrastive Learning of Unsupervised Sentence Representation无监督句子表示中的对比学习去偏

论文地址：https://arxiv.org/abs/2205.00656v1

Comments:11 pages, accepted by ACL 2022 main conferenceSubjects:Computation and Language (cs.CL)Cite as:arXiv:2205.00656 [cs.CL] (or arXiv:2205.00656v1 [cs.CL] for this version) https://doi.org/10.48550/arXiv.2205.00656

自己也是看了别人的讲解，来源：B站揣摩研习社 记录以学习回忆

研究背景

对比学习通过子监督的方式预训练，可以促使模型得到高质量的句子表示。

对比学习一般采用随机组成的batch内其它样本作为负例，这一采样方式可能会导致采样偏差。

batch内其他样本也不一定全是负样本。

由于PLM表示是各向异性的，只使用PLM的表示来优化是不充分的。

（自注：PLM是什么？这里指的是 与训练语言模型。这里它提到用PLM表示的空间像一个锥形空间，用这个锥形空间不充分）

对比学习概念 Contrastive learning

同一个样本经过两个不同的数据增强作为一个正样本对。

本文方法

提出了两种方法

1.基于噪声生成负例

缓解各向异性导致的优化不充分问题

2.设计负样本权重

缓解false negative问题（自注：这里false negative到底是什么问题 不太明确啊 难带是这个？False Negative (简称FN)：判断为负，但是判断错了。（实际为正））

基于噪声生成负例

从高斯分布采样k个噪声向量，作为PLM表示空间外的负例（自注：这里PLM表示空间外是什么意思，还得看看原文）

为了提高负例的质量，利用梯度提升来调整k个噪声负例

设计负样本权重

利用预训练好的SimSCE计算样本表示的相似度，根据相似度设定权重。

自注：小于阈值 就说明是个负样本。这里好奇怪啊，你这个本来就是生成更好的句向量，怎么还用到了别人的句向量模型SimCSE

模型方法

实验部分

数据集：STS-语义相似度

预训练模型 ：BERT RoBERTa

评价方式：语义相似度：余弦相似度于groud truth相似度的Sperman相关洗漱

消融实验

Original: https://www.cnblogs.com/nlpers/p/16298493.html
Author: nlp如此迷人
Title: Debiased Contrastive Learning of Unsupervised Sentence Representation无监督句子表示中的对比学习去偏

相关阅读2

Title: ubuntu20.04 安装rocm及tensorflow-rocm记录（已放弃）

目录

*
- 1.原因
- 2.准备
- 3.ubuntu20系统问题
- 4.安装rocm问题
- 5.安装tensorflow-rocm
- 6.amd从入门到放弃：
- 7. nvida回来评价，cuda安装真方便，入门真省事

1.原因

只有一块amd显卡rx580，最近显卡又贵，不想换，想着便宜了买块新1660

2.准备

首先要准备ubuntu系统，去官网下载，百度搜ubuntu就是。
一开始我总是把ubuntu写成ubantu，没发现搜错。
之后准备安装双系统，这是按照他人的文章一步步作的。
后来重装了很多次，发现ubuntu安装分区时不需要那么麻烦，记住分'/'，'/home'，'/snap'和启动项就行了。

3.ubuntu20系统问题

我第一次装完系统，发现software-center打不开，也无法使用软件安装，安装这篇文章的方法操作了下，至少能安装软件了
毕竟萌新，命令行安装还是麻烦
后来rocm卸载后在安装总是有依赖问题无法安装部分包，放弃了，再次重装系统，就没有software的问题了，玄学

4.安装rocm问题

安装官网文件
https://rocmdocs.amd.com/en/latest/Installation_Guide/Installation-Guide.html
一步步安装，
有发现一个问题，应该是两个

/opt/rocm/bin/rocminfo
/opt/rocm/opencl/bin/clinfo

这一部总是无法正常 显示gpu，根据百度翻译，确认两个问题

1.对/dev/kfd文件无权限，
搜索permission denied查到文章
ubuntu下使用filezilla上传文件权限问题（open for write: permission denied）.

使用

sudo chmod 777 /dev/kfd

获取权限

另外需要将用户加入render组
好多安装rocm都没有提到这个问题，一般都加入video组就下一步了

加入render组后可以正常显示gpu信息了

5.安装tensorflow-rocm

至今没明白一个问题
tensorflow 是cpu版本
tensorflow-gpu是nivda版本
tensorflow-rocm是amd显卡版本是吗？

这一部依旧安装官方文档:Tensorflow安装.

现在又遇到一个问题，系统中python3 可以调用tensorflow，但pycharm无tensorflow，一会重启试一下。

测试tensorflow能否使用gpu;

import tensorflow as tf
tf.config.list_physical_devices('GPU')

结果

2021-04-10 14:10:07.680782: I tensorflow/compiler/jit/xla_cpu_device.cc:41] Not creating XLA devices, tf_xla_enable_xla_devices not set
2021-04-10 14:10:07.681037: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libamdhip64.so
2021-04-10 14:10:07.725922: I tensorflow/core/common_runtime/gpu/gpu_device.cc:1734] Found device 0 with properties:
pciBusID: 0000:29:00.0 name: Ellesmere [Radeon RX 470/480/570/570X/580/580X/590]     ROCm AMDGPU Arch: gfx803
coreClock: 1.34GHz coreCount: 36 deviceMemorySize: 8.00GiB deviceMemoryBandwidth: 119.21GiB/s
2021-04-10 14:10:07.728730: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library librocblas.so
2021-04-10 14:10:07.729808: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libMIOpen.so
2021-04-10 14:10:07.744546: I tensorflow/stream_executor/platform/default/dso_loader.cc:53] Successfully opened dynamic library libhipfft.so
"hipErrorNoBinaryForGpu: Unable to find code object for all current devices!"
已放弃 (核心已转储)

6.amd从入门到放弃：

放弃原因，后来rocm始终无法正确安装，后来在英文网站中找到原因，垃圾amd的rocm4.0放弃rx580显卡，需要更新的型号才能安装4.0，否则需要安装旧版本rocm,放弃了。。。

已放弃此方法，以后再看看吧

后来又遇到rocm支持5600XT等显卡，RX580需安装之前的rocm版本，我就放弃了，真麻烦，早知道直接nvdia 万岁

7. nvida回来评价，cuda安装真方便，入门真省事

Original: https://blog.csdn.net/qq571028495/article/details/115572663
Author: 认真学习pytorch
Title: ubuntu20.04 安装rocm及tensorflow-rocm记录（已放弃）

相关阅读3

Title: 使用 deb 包的方式安装 TensorRT

使用 deb 包的方式安装 TensorRT

完成日期：2022 年 4 月 17 日
最后修改：----
此文使用 markdown 完成

要在 ubuntu 下使用 TensorRT，可以选择下载 deb 包本地安装。和使用 pip wheel 不同，这种安装方式可以同时支持 python 和 C++ 的接口。这种方式会把 TensorRT 给安装到我们的操作系统里，和安装其他的一些包类似，也不用再配置一些环境变量之类的东西，但是这样的话就只能安装一个版本的 TensorRT，不可以多版本共存。如果想要同时能用不同的版本，要用 tar 包的方式安装。

• 一块英伟达的 GPU（这不是废话吗 →_→）
• 安装好 GPU 驱动
• 安装好 CUDA

安装的 CUDA 版本要与 驱动和 TensorRT 保持一致，驱动可以直接打开"软件和更新"->"附加驱动"，里面选一个，建议不要用最新的，因为目前 TensorRT 8.2 支持到 CUDA 11.5，如果装的是 11.6 之类的（比如说我）后面会报错。如果出现类似下面这样的错误：

下列软件包有未满足的依赖关系：
 tensorrt : 依赖: libnvinfer5 (= 5.0.2-1+cuda9.0) 但是它将不会被安装
            依赖: libnvinfer-dev (= 5.0.2-1+cuda9.0) 但是它将不会被安装
            依赖: libnvinfer-samples (= 5.0.2-1+cuda9.0) 但是它将不会被安装
E: 无法修正错误，因为您要求某些软件包保持现状，就是它们破坏了软件包间的依赖关系。

那估计就是是 CUDA 版本的问题。这里错误说的是包之间不兼容，可能的原因有：

• 没装驱动（没驱动当然找不到合适的包啦）
• 没装 CUDA
• TensorRT 版本选错了
• 上一次安装错误的 TensorRT 没有被卸载干净

这里又有两个巨坑：

先说怎么安装 CUDA，它的版本要和驱动的一致。如果自己手动用命令行安装驱动，可以在装驱动的时候顺便把 CUDA 也一起装了。这里是官方的 CUDA 安装文档，没装的话，可以先用 nvidia-smi 命令来查询，会出来一个表格，右上角可以看到 CUDA 版本：

+-----------------------------------------------------------------------------+
| NVIDIA-SMI 470.103.01   Driver Version: 470.103.01   CUDA Version: 11.4     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|                               |                      |               MIG M. |
|===============================+======================+======================|
|   0  NVIDIA GeForce ...  Off  | 00000000:01:00.0 Off |                  N/A |
| N/A   52C    P5    N/A /  N/A |    158MiB /  4046MiB |      7%      Default |
|                               |                      |                  N/A |
+-------------------------------+----------------------+----------------------+

之后直接去下载安装就行，这里是英伟达 CUDA 下载页面，选择好自己的系统、版本等信息，建议最后一项选择"deb[local]"，先下载下来本地安装，英伟达的网络有时候也不咋地。这个页面默认提供的是最新版的 CUDA，如果要安装旧版本的，需要点击下方的"Archive of Previous CUDA Releases"页面，选择我们需要的版本。需要注意的是，这里会把 CUDA 安装在操作系统里，如果需要在 Conda 虚拟环境里使用 TensorRT，还是要在虚拟环境里重新安装一下 CUDA。

安装 TensorRT 的过程很简单，直接按官方教程来就行了。先使用下面的命令解包：

sudo dpkg -i [之前下载好的 deb 包的名字]

再添加本地仓库的源秘钥，我们安装的时候会把刚刚解包好的目录作为一个本地源，从那里安装，就不是像一般用 apt 命令安装的时候一样，从网络源下载了。添加完成后可以从图形界面的 "软件和更新" -> "其他软件"里面看到，弄错了可以从这里删掉。

sudo apt-key add /var/[还是 deb 包的名字]/7fa2af80.pub

上面那个目录其实就是之前用 dpkg 命令解包出来，默认是放在 /var/ 路径下面，里面会有一个秘钥，添加它就行了。之后直接安装就行

sudo apt-get update  # 也可以先更新一下源信息
sudo apt-get install tensorrt

到这一步其实就已经安装完了，还有几个小组件可以一并装上：

sudo apt-get install python3-libnvinfer-dev  # 这玩意是用 python 接口推理用的，
                                             # 装之前要先装 numpy

pip install protobuf  # 这俩是配合 TensorFlow 使用的，有一些 TensorRT 例子会用到，
sudo apt-get install uff-converter-tf  # 不过貌似现在不太用 uff，一般用 onnx

pip numpy onnx  # 这俩是配合 onnx 模型使用的，有时候要使用官方的 TensorRT plugins，
apt-get install onnx-graphsurgeon  # 就要用 onnx-graphsurgeon 去修改 onnx 图

安装完成后，使用管道命令查询一下包列表，看看有没有安装成功：

dpkg -l | grep TensorRT

如果成功的话，会列出所有 TensorRT 相关的包，看起来像下面这样：

ii  graphsurgeon-tf          8.2.4-1+cuda11.4    amd64    GraphSurgeon for TensorRT package
ii  libnvinfer-bin           8.2.4-1+cuda11.4    amd64    TensorRT binaries
ii  libnvinfer-dev           8.2.4-1+cuda11.4    amd64    TensorRT development libraries and headers
ii  libnvinfer-doc           8.2.4-1+cuda11.4    all      TensorRT documentation
ii  libnvinfer-plugin-dev    8.2.4-1+cuda11.4    amd64    TensorRT plugin libraries
...

...

第 1 个坑说白了就是要在安装前，一定要先验证一下有没有装好 CUDA，可以用下面的命令查询一下：

dpkg -l | grep cuda  # 会像上面一样，列出所有 CUDA 相关的包

不要用 nvcc 命令去查询，系统只会提示没有安装好 nvidia-cuda-toolkit，我们只需要单独的 CUDA，实测装了 nvidia-cuda-toolkit 也没啥用，还是会提示找不到 CUDA
第 2 个巨坑就是 dpkg 命令的原因的。第一次安装失败后，会有残留的配置文件，会导致第二次安装失败，使用 dpkg --remove <软件包名><!--软件包名--> 命令卸载时， --remove 是不会删除配置文件，只有用 --purge命令才会删除相应的配置文件，用 dpkg -l 列出所安装的包时，前面的 ii 表示正常安装的包，如果是 re 开头的，就表示 包已经被移除，但仍然还保留着它的配置文件，可以使用下面的命令来清理：

sudo dpkg -P   # -P 就是 --purge 的短选项形式，是一样的

• TensorRT 依赖有：显卡驱动、CUDA
• pycuda 需要在安装 CUDA 后再安装
• 安装失败的残留文件要清理掉，不然会出现冲突
• 使用 dpkg -P <软件包名><!--软件包名--> 可以完全清理，包括配置文件

Original: https://www.cnblogs.com/asnelin/p/16102862.html
Author: Asnelin
Title: 使用 deb 包的方式安装 TensorRT