昇思25天学习打卡营第4天|常见的数据变换 Transforms类型

导入数据集相关库和模块

---

        首先导入了一些必要的库和模块，包括 numpy（np 是其常用的别名）、PIL 库中的 Image 模块，以及自定义的 download 模块，还有 mindspore.dataset 中的 transforms、vision、text 模块。然后使用 mindspore.dataset 中的 GeneratorDataset 和 MnistDataset 。这通常是为了后续处理和操作数据集做准备。

        代码如下：

import numpy as np  
from PIL import Image  
from download import download  
from mindspore.dataset import transforms, vision, text  
from mindspore.dataset import GeneratorDataset, MnistDataset 

Common Transforms

---

        Compose接收一个数据增强操作序列，然后将其组合成单个数据增强操作。我们仍基于Mnist数据集呈现Transforms的应用效果。

        代码如下：

# Download data from open datasets  
url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/" \  
      "notebook/datasets/MNIST_Data.zip"  
path = download(url, "./", kind="zip", replace=True)  
train_dataset = MnistDataset('MNIST_Data/train')  

        分析：首先定义了一个下载数据的网址 url 。然后调用 download 函数从给定的网址下载数据，并将其保存到当前目录下（"./"），文件类型为 zip ，如果已存在则进行替换。最后使用 MnistDataset 类加载名为 'MNIST_Data/train' 的训练数据集。

        运行结果：

        代码如下：

image, label = next(train_dataset.create_tuple_iterator())  
print(image.shape)  
composed = transforms.Compose(  
    [  
        vision.Rescale(1.0 / 255.0, 0),  
        vision.Normalize(mean=(0.1307,), std=(0.3081,)),  
        vision.HWC2CHW()  
    ]  
)  
train_dataset = train_dataset.map(composed, 'image')  
image, label = next(train_dataset.create_tuple_iterator())  
print(image.shape)  

        分析：首先，从训练数据集 train_dataset 中获取下一个样本，并将图像数据和标签分别赋值给 image 和 label ，然后打印出图像数据的形状。接着，定义了一个数据变换的组合 composed ，其中包含了三个数据变换操作：将像素值缩放到 0 到 1 之间、进行标准化、将图像的通道顺序从 HWC 转换为 CHW 。然后，使用 map 方法将这个组合变换应用到训练数据集的 image 列。最后，再次从经过变换的训练数据集中获取下一个样本，并将图像数据和标签分别赋值给 image 和 label ，然后再次打印出图像数据的形状，以查看变换后的效果。

        运行结果：

        (28, 28, 1)

        (1, 28, 28)

Vision Transforms

---

Rescale

        代码如下：

random_np = np.random.randint(0, 255, (48, 48), np.uint8)  
random_image = Image.fromarray(random_np)  
print(random_np) 

        分析：首先使用 np.random.randint 函数生成一个取值范围在 0 到 255 之间、形状为 (48, 48) 且数据类型为 np.uint8 的随机整数数组 random_np 。然后通过 Image.fromarray 函数将这个随机数组转换为 Image 对象 random_image 。最后打印出 random_np 数组。

        运行结果：

[[ 82 253  82 ... 150 245  93]

 [ 66 174  93 ...  67 180  23]

 [106 232 100 ... 224  10  48]

 ...

 [ 37 201 109 ...   7  22 109]

 [153 232  12 ...  67 131  36]

 [231 127  37 ...  15 163  71]]

        代码如下：

rescale = vision.Rescale(1.0 / 255.0, 0)  
rescaled_image = rescale(random_image)  
print(rescaled_image)  

        分析：Rescale变换用于调整图像像素值的大小，包括两个参数：rescale：缩放因子。shift：平移因子。

        运行结果：

        [[0.32156864 0.9921569  0.32156864 ... 0.5882353  0.9607844  0.3647059 ]

         [0.25882354 0.68235296 0.3647059  ... 0.2627451  0.7058824  0.09019608]

         [0.4156863  0.909804   0.3921569  ... 0.87843144 0.03921569 0.18823531]

         ...

         [0.14509805 0.78823537 0.427451   ... 0.02745098 0.08627451 0.427451  ]

         [0.6        0.909804   0.04705883 ... 0.2627451  0.5137255  0.14117648]

         [0.9058824  0.49803925 0.14509805 ... 0.05882353 0.6392157  0.2784314 ]]

Normalize

        Normalize变换用于对输入图像的归一化，包括三个参数：

        mean：图像每个通道的均值。

        std：图像每个通道的标准差。

        is_hwc：bool值，输入图像的格式。True为(height, width, channel)，False为(channel, height, width)。

        代码如下：

normalize = vision.Normalize(mean=(0.1307,), std=(0.3081,))  
normalized_image = normalize(rescaled_image)  
print(normalized_image)  

        分析：首先创建了一个名为 normalize 的标准化变换对象，其均值为 (0.1307,) ，标准差为 (0.3081,) 。然后将经过缩放处理的图像 rescaled_image 应用这个标准化变换，得到标准化后的图像 normalized_image 。最后打印出标准化后的图像。

        运行结果：

        [[ 0.61950225  2.7960305   0.61950225 ...  1.4850222   2.6942046

           0.7595128 ]

         [ 0.41585052  1.7904998   0.7595128  ...  0.42857873  1.8668692

          -0.13146357]

         [ 0.92498     2.5287375   0.8486106  ...  2.4269116  -0.29693064

           0.18674232]

         ...

         [ 0.04673171  2.1341622   0.9631647  ... -0.33511534 -0.14419182

           0.9631647 ]

         [ 1.523207    2.5287375  -0.27147415 ...  0.42857873  1.2431858

           0.03400347]

         [ 2.5160093   1.1922729   0.04673171 ... -0.23328944  1.6504892

           0.47949168]]

HWC2CHW

        HWC2CHW变换用于转换图像格式。在不同的硬件设备中可能会对(height, width, channel)或(channel, height, width)两种不同格式有针对性优化。MindSpore设置HWC为默认图像格式，在有CHW格式需求时，可使用该变换进行处理。

        代码如下：

hwc_image = np.expand_dims(normalized_image, -1)  
hwc2chw = vision.HWC2CHW()  
chw_image = hwc2chw(hwc_image)  
print(hwc_image.shape, chw_image.shape) 

        分析：在 Python 中，利用 NumPy 库和一些图像处理相关操作来处理图像数据。这段代码借助 NumPy 的 expand_dims 函数，在 normalized_image 的最后一个维度添加了一个新维度。接着创建了一个叫做 hwc2chw 的对象，它是用于实现图像维度转换的。然后使用先前创建的这个对象对 hwc_image 进行转换，从而得到 chw_image 。最后打印出 hwc_image 和 chw_image 的形状。形状一般是以元组的形式呈现，其中包含了每个维度的尺寸大小。通过打印形状，能够清楚地知晓图像在处理前后维度上的变化状况。

        运行结果：

        (48, 48, 1) (1, 48, 48)

Text Transforms

---

PythonTokenizer

        代码如下：

texts = ['Welcome to Beijing']  
test_dataset = GeneratorDataset(texts, 'text')  
def my_tokenizer(content):  
    return content.split()  
test_dataset = test_dataset.map(text.PythonTokenizer(my_tokenizer))  
print(next(test_dataset.create_tuple_iterator()))  

        分析：首先定义了一个名为 texts 的列表，其中包含一个字符串 'Welcome to Beijing' 。

        然后创建了一个名为 test_dataset 的数据集，数据来源于 texts 列表，并且数据的类别被标记为 'text' 。

        接下来定义了一个名为 my_tokenizer 的函数，它的作用是将输入的内容按照空格分割成单词。之后，test_dataset 数据集通过 map 方法应用 my_tokenizer 函数进行处理，即将每个文本数据按照函数的规则进行分割。

        最后，通过 next(test_dataset.create_tuple_iterator()) 打印出处理后的数据集的第一个元素。

        运行结果：

        [Tensor(shape=[3], dtype=String, value= ['Welcome', 'to', 'Beijing'])]

Lookup

        代码如下：

vocab = text.Vocab.from_dataset(test_dataset)  
print(vocab.vocab())  
test_dataset = test_dataset.map(text.Lookup(vocab))  
print(next(test_dataset.create_tuple_iterator()))  

        运行结果：

        {'to': 2, 'Welcome': 1, 'Beijing': 0}

        [Tensor(shape=[3], dtype=Int32, value= [1, 2, 0])]

Lambda Transforms

---

        代码如下：

test_dataset = GeneratorDataset([1, 2, 3], 'data', shuffle=False)  
test_dataset = test_dataset.map(lambda x: x * 2)  
print(list(test_dataset.create_tuple_iterator()))  
def func(x):  
    return x * x + 2  
test_dataset = test_dataset.map(lambda x: func(x))  
print(list(test_dataset.create_tuple_iterator()))

        分析：

        首先创建了一个名为 test_dataset 的数据集，数据是列表 [1, 2, 3] ，数据类别标记为 'data' ，并且设置不打乱数据顺序。

        然后对 test_dataset 中的每个元素进行映射操作，即将每个元素乘以 2 。

        接着打印出经过第一次映射处理后的数据集元素，通过将迭代器转换为列表并打印出来。

        之后定义了一个名为 func 的函数，用于计算输入值的平方加 2 。

        然后再次对 test_dataset 进行映射操作，这次使用 func 函数对每个元素进行处理。

        最后再次打印出经过第二次映射处理后的数据集元素，同样通过将迭代器转换为列表并打印出来。

        运行结果：

        [[Tensor(shape=[], dtype=Int64, value= 2)], [Tensor(shape=[], dtype=Int64, value= 4)],         [Tensor(shape=[], dtype=Int64, value= 6)]]

        [[Tensor(shape=[], dtype=Int64, value= 6)], [Tensor(shape=[], dtype=Int64, value= 18)],         [Tensor(shape=[], dtype=Int64, value= 38)]]

        打印时间：

import time
print(time.strftime("%Y-%m-%d %H:%M:%S",time.localtime()),'qianduanjidi')

        运行截图：