《昇思25天学习打卡营第04天|qingyun201003》

日期

心得

从中认识到什么是数据转换，如何进行数据转换；对于数据转换应该如何理解。同时对于数据转换的代码有了深层次的理解。对于数据增强、转换、归一化有了明确的认知。

昇思MindSpore 基础入门学习数据转换 (AI 代码解析)

数据变换 Transforms

通常情况下，直接加载的原始数据并不能直接送入神经网络进行训练，此时我们需要对其进行数据预处理。MindSpore提供不同种类的数据变换（Transforms），配合数据处理Pipeline来实现数据预处理。所有的Transforms均可通过map方法传入，实现对指定数据列的处理。
mindspore.dataset提供了面向图像、文本、音频等不同数据类型的Transforms，同时也支持使用Lambda函数。下面分别对其进行介绍。

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

import numpy as np:
- numpy: 这是一个强大的数值计算库，广泛用于数组操作和数学运算。
- np: 这是 numpy 的别名，方便在代码中使用。
from PIL import Image:
- PIL: Python Imaging Library (PIL) 是一个图像处理库，现在被 Pillow 项目继承和扩展。
- Image: Image 模块提供了图像处理的基本功能，如打开、保存和编辑图像。
from download import download:
- download: 这个模块或函数可能用于从网络下载文件。具体功能取决于 download 模块的实现。
from mindspore.dataset import transforms, vision, text:
- mindspore.dataset: MindSpore 是一个深度学习框架，dataset 模块提供了数据集处理的相关功能。
- transforms: 这个模块提供了数据预处理和数据增强的转换函数。
- vision: 这个模块提供了图像相关的数据处理和增强功能。
- text: 这个模块提供了文本数据处理的功能。
from mindspore.dataset import GeneratorDataset, MnistDataset:
- GeneratorDataset: 这是一个数据集类，用于从生成器创建数据集。生成器可以是一个函数，用于动态生成数据。
- MnistDataset: 这是一个预定义的数据集类，用于加载和处理 MNIST 数据集，MNIST 是一个手写数字图像数据集，常用于机器学习模型的训练和测试。

这些导入语句为后续的代码提供了必要的工具和功能，以便进行数据处理、图像处理和深度学习模型的训练。

Common Transforms

mindspore.dataset.transforms模块支持一系列通用Transforms。这里我们以Compose为例，介绍其使用方式。

Compose

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

from download import download
from mindspore.dataset import MnistDataset# 定义数据集的URL
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')

download** 函数**:
- url: 数据集的下载链接。
- “./”: 下载文件的保存路径，这里表示当前目录。
- kind=“zip”: 指定下载的文件类型为ZIP压缩文件。
- replace=True: 如果目标路径已存在同名文件，则替换它。
MnistDataset** 类**:
- ‘MNIST_Data/train’: 指定MNIST训练数据集的路径。这个路径是基于下载和解压后的文件结构。

通过这段代码，你可以从指定的URL下载MNIST数据集的ZIP文件，并将其解压到当前目录。然后，使用MnistDataset类加载解压后的训练数据集。

image, label = next(train_dataset.create_tuple_iterator())
print(image.shape)

train_dataset.create_tuple_iterator():
- create_tuple_iterator: 这是一个数据集方法，用于创建一个迭代器，该迭代器可以逐个返回数据集中的元素。每个元素是一个元组，包含图像和对应的标签。
next** 函数**:
- next: 这是一个内置函数，用于从迭代器中获取下一个元素。在这里，它获取训练数据集中的第一个元素，即一个图像和对应的标签。
image.shape:
- image: 这是一个NumPy数组，表示从数据集中获取的图像。
- shape: 这是NumPy数组的属性，返回数组的形状，即维度信息。例如，如果图像的形状是 (1, 28, 28)，表示这是一个单通道的28x28像素图像。

通过这段代码，你可以获取训练数据集中的第一个图像及其形状信息，并打印出来。这对于验证数据集的加载和预处理是否正确非常有用。

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)

transforms.Compose:
- Compose: 这是一个组合多个数据增强操作的类。它接收一个操作序列，并将其组合成单个操作。这样可以在数据集上一次性应用多个增强操作。
数据增强操作序列:
- vision.Rescale: 将图像的像素值从原始的[0, 255]缩放到[0, 1]范围内。参数 1.0 / 255.0 用于缩放，0 是偏移量。
- vision.Normalize: 对图像进行标准化处理，使其均值为0，标准差为1。参数 mean=(0.1307,) 和 std=(0.3081,) 分别是均值和标准差。
- vision.HWC2CHW: 将图像的通道顺序从 “Height-Width-Channel” (HWC) 转换为 “Channel-Height-Width” (CHW)。这是为了适应一些深度学习模型的输入要求。
train_dataset.map:
- map: 这是一个数据集方法，用于对数据集中的每个元素应用指定的操作。参数 composed 指定要应用的操作，'image' 指定要应用操作的列（这里是图像列）。
train_dataset.create_tuple_iterator():
- create_tuple_iterator: 这是一个数据集方法，用于创建一个迭代器，该迭代器可以逐个返回数据集中的元素。每个元素是一个元组，包含图像和对应的标签。
next** 函数**:
- next: 这是一个内置函数，用于从迭代器中获取下一个元素。在这里，它获取训练数据集中的第一个元素，即一个图像和对应的标签。
image.shape:
- image: 这是一个NumPy数组，表示从数据集中获取的图像。
- shape: 这是NumPy数组的属性，返回数组的形状，即维度信息。例如，如果图像的形状是 (1, 28, 28)，表示这是一个单通道的28x28像素图像。

通过这段代码，你可以对训练数据集中的图像进行一系列的数据增强操作，并获取处理后的图像及其形状信息，并打印出来。这对于验证数据集的加载和预处理是否正确非常有用。

Vision Transforms

mindspore.dataset.vision模块提供一系列针对图像数据的Transforms。在Mnist数据处理过程中，使用了Rescale、Normalize和HWC2CHW变换。下面对其进行详述。

Rescale

Rescale变换用于调整图像像素值的大小，包括两个参数：

rescale：缩放因子。
shift：平移因子。

图像的每个像素将根据这两个参数进行调整，输出的像素值为outputi=inputi∗rescale+shift𝑜𝑢𝑡𝑝𝑢𝑡𝑖=𝑖𝑛𝑝𝑢𝑡𝑖∗𝑟𝑒𝑠𝑐𝑎𝑙𝑒+𝑠ℎ𝑖𝑓𝑡。
这里我们先使用numpy随机生成一个像素值在[0, 255]的图像，将其像素值进行缩放。

import numpy as np
from PIL import Image# 随机生成一个像素值在[0, 255]的48x48图像
random_np = np.random.randint(0, 255, (48, 48), np.uint8)# 将NumPy数组转换为PIL图像
random_image = Image.fromarray(random_np)# 打印生成的随机图像的NumPy数组
print(random_np)

numpy.random.randint:
- randint: 这是一个NumPy函数，用于生成指定范围内的随机整数。这里生成一个48x48的图像，像素值在[0, 255]之间。
Image.fromarray:
- fromarray: 这是PIL库中的一个函数，用于将NumPy数组转换为PIL图像对象。
打印生成的随机图像的NumPy数组:
- print(random_np): 打印生成的随机图像的NumPy数组，显示图像的像素值。

通过这段代码，你可以生成一个随机图像，并将其转换为PIL图像对象，同时打印出图像的NumPy数组表示。这对于验证图像生成和转换是否正确非常有用。

为了更直观地呈现Transform前后的数据对比，我们使用Transforms的Eager模式进行演示。首先实例化Transform对象，然后调用对象进行数据处理。

from mindspore.dataset import vision
from PIL import Image
import numpy as np# 随机生成一个像素值在[0, 255]的48x48图像
random_np = np.random.randint(0, 255, (48, 48), np.uint8)
random_image = Image.fromarray(random_np)# 创建Rescale变换
rescale = vision.Rescale(1.0 / 255.0, 0)# 应用Rescale变换
rescaled_image = rescale(random_image)# 打印缩放后的图像
print(rescaled_image)

vision.Rescale:
- Rescale: 这是MindSpore的vision模块中的一个变换，用于调整图像像素值的大小。参数 1.0 / 255.0 是缩放因子，0 是平移因子。
应用Rescale变换:
- rescale(random_image): 将Rescale变换应用到生成的PIL图像上，返回缩放后的图像。
打印缩放后的图像:
- print(rescaled_image): 打印缩放后的图像。需要注意的是，rescaled_image 是一个NumPy数组，因此打印出来的是数组的表示形式。

由于 rescaled_image 是一个NumPy数组，直接打印它将显示数组的值。如果你希望查看图像的像素范围或形状，可以使用以下代码：

print("Rescaled image shape:", rescaled_image.shape)
print("Rescaled image pixel range:", np.min(rescaled_image), np.max(rescaled_image))

这样可以更清楚地看到缩放后的图像的形状和像素值范围。

为了更直观地呈现Transform前后的数据对比，我们使用Transforms的Eager模式进行演示。首先实例化Transform对象，然后调用对象进行数据处理。

from mindspore.dataset import vision
from PIL import Image
import numpy as np# 随机生成一个像素值在[0, 255]的48x48图像
random_np = np.random.randint(0, 255, (48, 48), np.uint8)
random_image = Image.fromarray(random_np)# 创建Rescale变换
rescale = vision.Rescale(1.0 / 255.0, 0)# 应用Rescale变换
rescaled_image = rescale(random_image)# 打印缩放后的图像
print(rescaled_image)

vision.Rescale:
- Rescale: 这是MindSpore的vision模块中的一个变换，用于调整图像像素值的大小。参数 1.0 / 255.0 是缩放因子，0 是平移因子。
应用Rescale变换:
- rescale(random_image): 将Rescale变换应用到生成的PIL图像上，返回缩放后的图像。需要注意的是，rescale 变换期望输入是一个NumPy数组，而不是PIL图像对象。因此，这段代码可能会抛出错误。
打印缩放后的图像:
- print(rescaled_image): 打印缩放后的图像。由于 rescaled_image 是一个NumPy数组，直接打印它将显示数组的值。

Normalize

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

mean：图像每个通道的均值。
std：图像每个通道的标准差。
is_hwc：bool值，输入图像的格式。True为(height, width, channel)，False为(channel, height, width)。

图像的每个通道将根据mean和std进行调整，计算公式为outputc=inputc−meancstdc𝑜𝑢𝑡𝑝𝑢𝑡𝑐=𝑖𝑛𝑝𝑢𝑡𝑐−𝑚𝑒𝑎𝑛𝑐𝑠𝑡𝑑𝑐，其中 c𝑐代表通道索引。

from mindspore.dataset import vision
from PIL import Image
import numpy as np# 随机生成一个像素值在[0, 255]的48x48图像
random_np = np.random.randint(0, 255, (48, 48), np.uint8)
random_image = Image.fromarray(random_np)# 将PIL图像转换为NumPy数组
random_np = np.array(random_image)# 创建Rescale变换
rescale = vision.Rescale(1.0 / 255.0, 0)# 应用Rescale变换
rescaled_image = rescale(random_np)# 定义归一化的均值和标准差
mean = (0.1307,)
std = (0.3081,)# 创建Normalize变换
normalize = vision.Normalize(mean=mean, std=std)# 应用Normalize变换
normalized_image = normalize(rescaled_image)# 打印归一化后的图像
print(normalized_image)

vision.Normalize:
- Normalize: 这是MindSpore的vision模块中的一个变换，用于对图像进行归一化处理。参数 mean 和 std 分别是图像每个通道的均值和标准差。在这个例子中，mean 和 std 都是单元素元组，适用于单通道图像（例如灰度图像）。
应用Normalize变换:
- normalize(rescaled_image): 将Normalize变换应用到缩放后的图像上，返回归一化后的图像。归一化的计算公式为 output_c = (input_c - mean_c) / std_c，其中 c 代表通道索引。
打印归一化后的图像:
- print(normalized_image): 打印归一化后的图像。由于 normalized_image 是一个NumPy数组，直接打印它将显示数组的值。

请注意，rescaled_image 是一个单通道的灰度图像，因此 mean 和 std 都是单元素元组。如果你的图像是多通道的（例如RGB图像），你需要为每个通道提供相应的均值和标准差。

HWC2CHW

HWC2CHW变换用于转换图像格式。在不同的硬件设备中可能会对(height, width, channel)或(channel, height, width)两种不同格式有针对性优化。MindSpore设置HWC为默认图像格式，在有CHW格式需求时，可使用该变换进行处理。
这里我们先将前文中normalized_image处理为HWC格式，然后进行转换。可以看到转换前后的shape发生了变化。

from mindspore.dataset import vision
from PIL import Image
import numpy as np# 随机生成一个像素值在[0, 255]的48x48图像
random_np = np.random.randint(0, 255, (48, 48), np.uint8)
random_image = Image.fromarray(random_np)# 将PIL图像转换为NumPy数组
random_np = np.array(random_image)# 创建Rescale变换
rescale = vision.Rescale(1.0 / 255.0, 0)# 应用Rescale变换
rescaled_image = rescale(random_np)# 定义归一化的均值和标准差
mean = (0.1307,)
std = (0.3081,)# 创建Normalize变换
normalize = vision.Normalize(mean=mean, std=std)# 应用Normalize变换
normalized_image = normalize(rescaled_image)# 将单通道图像扩展为HWC格式
hwc_image = np.expand_dims(normalized_image, -1)# 创建HWC2CHW变换
hwc2chw = vision.HWC2CHW()# 应用HWC2CHW变换
chw_image = hwc2chw(hwc_image)# 打印HWC和CHW图像的形状
print(hwc_image.shape, chw_image.shape)

np.expand_dims:
- np.expand_dims(normalized_image, -1): 在最后一个维度上扩展维度，将单通道图像转换为HWC格式（高度、宽度、通道）。这样，hwc_image 的形状将从 (48, 48) 变为 (48, 48, 1)。
vision.HWC2CHW:
- HWC2CHW: 这是MindSpore的vision模块中的一个变换，用于将图像从HWC格式（高度、宽度、通道）转换为CHW格式（通道、高度、宽度）。
应用HWC2CHW变换:
- hwc2chw(hwc_image): 将HWC2CHW变换应用到 hwc_image 上，返回CHW格式的图像。这样，chw_image 的形状将从 (48, 48, 1) 变为 (1, 48, 48)。
打印HWC和CHW图像的形状:
- print(hwc_image.shape, chw_image.shape): 打印HWC和CHW图像的形状。输出将是 (48, 48, 1) 和 (1, 48, 48)。

通过这段代码，你可以将单通道图像转换为HWC格式，然后进一步转换为CHW格式，并打印出两种格式的图像形状。这对于验证图像格式转换是否正确非常有用。

Text Transforms

mindspore.dataset.text模块提供一系列针对文本数据的Transforms。与图像数据不同，文本数据需要有分词（Tokenize）、构建词表、Token转Index等操作。这里简单介绍其使用方法。
首先我们定义三段文本，作为待处理的数据，并使用GeneratorDataset进行加载。

from mindspore.dataset import GeneratorDataset# 定义数据生成器
def text_generator(data):for text in data:yield (text,)# 创建文本数据集
texts = ['Welcome to Beijing']
test_dataset = GeneratorDataset(source=text_generator(texts), column_names=['text'])# 打印数据集中的数据
for data in test_dataset.create_dict_iterator():print(data)

GeneratorDataset:
- GeneratorDataset: 这是MindSpore的一个数据集类，用于从一个生成器函数创建数据集。source 是生成器函数，column_names 是数据集的列名。
定义数据生成器:
- text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
创建文本数据集:
- texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
- test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
打印数据集中的数据:
- for data in test_dataset.create_dict_iterator(): print(data): 使用 create_dict_iterator 创建一个迭代器来遍历数据集，并打印每条数据。

通过这段代码，你可以创建一个包含文本数据的 GeneratorDataset 数据集，并迭代打印数据集中的每条数据。这适用于需要从生成器创建自定义数据集的场景。

PythonTokenizer

分词（Tokenize）操作是文本数据的基础处理方法，MindSpore提供多种不同的Tokenizer。这里我们选择基础的PythonTokenizer举例，此Tokenizer允许用户自由实现分词策略。随后我们利用map操作将此分词器应用到输入的文本中，对其进行分词。

from mindspore.dataset import GeneratorDataset, text# 定义数据生成器
def text_generator(data):for text in data:yield (text,)# 创建文本数据集
texts = ['Welcome to Beijing']
test_dataset = GeneratorDataset(source=text_generator(texts), column_names=['text'])# 定义自定义分词器
def my_tokenizer(content):return content.split()# 应用自定义分词器
test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=['text'])# 打印数据集中的数据
print(next(test_dataset.create_tuple_iterator()))

定义数据生成器:
- text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
创建文本数据集:
- texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
- test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
定义自定义分词器:
- my_tokenizer(content): 这是一个简单的分词器函数，使用 split() 方法将输入文本按空格分割成单词列表。
应用自定义分词器:
- test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=[‘text’]): 使用 map 方法将自定义分词器应用到数据集的 text 列。text.PythonTokenizer 是一个MindSpore的API，用于将Python函数包装成分词器。
打印数据集中的数据:
- print(next(test_dataset.create_tuple_iterator())): 使用 create_tuple_iterator 创建一个迭代器来遍历数据集，并打印数据集中的第一条数据。

通过这段代码，你可以创建一个包含文本数据的 GeneratorDataset 数据集，并应用自定义分词器对文本进行分词，然后打印分词后的数据。这适用于需要对文本数据进行预处理的场景。

Lookup

Lookup为词表映射变换，用来将Token转换为Index。在使用Lookup前，需要构造词表，一般可以加载已有的词表，或使用Vocab生成词表。这里我们选择使用Vocab.from_dataset方法从数据集中生成词表。

from mindspore.dataset import GeneratorDataset, text
from mindspore.dataset.text import Vocab# 定义数据生成器
def text_generator(data):for text in data:yield (text,)# 创建文本数据集
texts = ['Welcome to Beijing']
test_dataset = GeneratorDataset(source=text_generator(texts), column_names=['text'])# 定义自定义分词器
def my_tokenizer(content):return content.split()# 应用自定义分词器
test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=['text'])# 创建词汇表
vocab = Vocab.from_dataset(test_dataset, columns=['text'])# 打印词汇表
print(vocab.vocab())# 使用词汇表映射文本数据
test_dataset = test_dataset.map(operations=text.Lookup(vocab), input_columns=['text'])# 打印数据集中的数据
print(next(test_dataset.create_tuple_iterator()))

定义数据生成器:
- text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
创建文本数据集:
- texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
- test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
定义自定义分词器:
- my_tokenizer(content): 这是一个简单的分词器函数，使用 split() 方法将输入文本按空格分割成单词列表。
应用自定义分词器:
- test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=[‘text’]): 使用 map 方法将自定义分词器应用到数据集的 text 列。text.PythonTokenizer 是一个MindSpore的API，用于将Python函数包装成分词器。
创建词汇表:
- vocab = Vocab.from_dataset(test_dataset, columns=[‘text’]): 从数据集的指定列创建一个词汇表 Vocab 对象。
打印词汇表:
- print(vocab.vocab()): 打印词汇表，显示词汇和其索引。
使用词汇表映射文本数据:
- test_dataset = test_dataset.map(operations=text.Lookup(vocab), input_columns=[‘text’]): 使用 map 方法将 text.Lookup 操作应用到数据集的 text 列，将文本数据映射为词汇索引。
打印数据集中的数据:
- print(next(test_dataset.create_tuple_iterator())): 使用 create_tuple_iterator 创建一个迭代器来遍历数据集，并打印数据集中的第一条数据。

通过这段代码，你可以创建一个包含文本数据的 GeneratorDataset 数据集，应用自定义分词器进行分词，创建词汇表 Vocab，将文本数据映射为词汇索引，并打印映射后的数据。这适用于需要对文本数据进行预处理并转换为索引表示的场景。

Lambda Transforms

Lambda函数是一种不需要名字、由一个单独表达式组成的匿名函数，表达式会在调用时被求值。Lambda Transforms可以加载任意定义的Lambda函数，提供足够的灵活度。在这里，我们首先使用一个简单的Lambda函数，对输入数据乘2：

from mindspore.dataset import GeneratorDataset# 创建数据集
test_dataset = GeneratorDataset([1, 2, 3], 'data', shuffle=False)# 应用映射操作
test_dataset = test_dataset.map(operations=lambda x: x * 2)# 打印数据集中的数据
print(list(test_dataset.create_tuple_iterator()))

创建数据集:
- test_dataset = GeneratorDataset([1, 2, 3], ‘data’, shuffle=False): 使用 GeneratorDataset 创建一个数据集，数据源是一个包含 [1, 2, 3] 的列表，列名为 'data'，并且不进行洗牌操作。
应用映射操作:
- test_dataset = test_dataset.map(operations=lambda x: x * 2): 使用 map 方法将一个匿名函数 lambda x: x * 2 应用到数据集的每一项数据上，将每个数据乘以 2。
打印数据集中的数据:
- print(list(test_dataset.create_tuple_iterator())): 使用 create_tuple_iterator 创建一个迭代器来遍历数据集，并将其转换为列表后打印。

通过这段代码，你可以创建一个包含 [1, 2, 3] 的数据集，应用映射操作将每个数据乘以 2，然后打印映射后的数据。这适用于需要对数据进行简单变换的场景。

from mindspore.dataset import GeneratorDataset# 定义函数
def func(x):return x * x + 2# 创建数据集
test_dataset = GeneratorDataset([1, 2, 3], 'data', shuffle=False)# 应用映射操作
test_dataset = test_dataset.map(operations=lambda x: func(x))# 打印数据集中的数据
print(list(test_dataset.create_tuple_iterator()))

定义函数:
- func(x): 这是一个简单的函数，接受一个输入 x，返回 x 的平方加上 2。
创建数据集:
- test_dataset = GeneratorDataset([1, 2, 3], ‘data’, shuffle=False): 使用 GeneratorDataset 创建一个数据集，数据源是一个包含 [1, 2, 3] 的列表，列名为 'data'，并且不进行洗牌操作。
应用映射操作:
- test_dataset = test_dataset.map(operations=lambda x: func(x)): 使用 map 方法将一个匿名函数 lambda x: func(x) 应用到数据集的每一项数据上，调用 func 函数对每个数据进行处理。
打印数据集中的数据:
- print(list(test_dataset.create_tuple_iterator())): 使用 create_tuple_iterator 创建一个迭代器来遍历数据集，并将其转换为列表后打印。

通过这段代码，你可以创建一个包含 [1, 2, 3] 的数据集，应用映射操作调用 func 函数对每个数据进行处理，然后打印处理后的数据。这适用于需要对数据进行复杂变换的场景。

整体代码

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# Download data from open datasetsurl = "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')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)random_np = np.random.randint(0, 255, (48, 48), np.uint8)
random_image = Image.fromarray(random_np)
print(random_np)rescale = vision.Rescale(1.0 / 255.0, 0)
rescaled_image = rescale(random_image)
print(rescaled_image)normalize = vision.Normalize(mean=(0.1307,), std=(0.3081,))
normalized_image = normalize(rescaled_image)
print(normalized_image)hwc_image = np.expand_dims(normalized_image, -1)
hwc2chw = vision.HWC2CHW()
chw_image = hwc2chw(hwc_image)
print(hwc_image.shape, chw_image.shape)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()))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()))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 + 2test_dataset = test_dataset.map(lambda x: func(x))
print(list(test_dataset.create_tuple_iterator()))

导入必要的库和模块：
- numpy：用于数值计算。
- PIL.Image：用于图像处理。
- download：用于下载数据集。
- mindspore.dataset：包含数据处理和变换的模块。
下载和加载数据集：
- 使用download函数下载MNIST数据集并解压。
- 使用MnistDataset加载训练数据集。
数据变换：
- Compose：组合多个变换操作。
- Rescale：调整图像像素值的大小。
- Normalize：对图像进行归一化处理。
- HWC2CHW：转换图像格式从HWC到CHW。
图像变换示例：
- 生成随机图像并应用Rescale和Normalize变换。
- 使用HWC2CHW变换转换图像格式。
文本变换示例：
- 使用PythonTokenizer进行分词。
- 使用Vocab生成词表并应用Lookup变换。
Lambda变换示例：
- 使用简单的Lambda函数对数据进行变换。
- 定义复杂函数并使用Lambda函数进行变换。