导入数据集相关库和模块
首先导入了一些必要的库和模块，包括 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')运行截图：
