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

  • 开发
  • 18

日期

image.png

心得

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

昇思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
  1. import numpy as np:
    • numpy: 这是一个强大的数值计算库，广泛用于数组操作和数学运算。
    • np: 这是 numpy 的别名，方便在代码中使用。
  2. from PIL import Image:
    • PIL: Python Imaging Library (PIL) 是一个图像处理库，现在被 Pillow 项目继承和扩展。
    • Image: Image 模块提供了图像处理的基本功能，如打开、保存和编辑图像。
  3. from download import download:
    • download: 这个模块或函数可能用于从网络下载文件。具体功能取决于 download 模块的实现。
  4. from mindspore.dataset import transforms, vision, text:
    • mindspore.dataset: MindSpore 是一个深度学习框架，dataset 模块提供了数据集处理的相关功能。
    • transforms: 这个模块提供了数据预处理和数据增强的转换函数。
    • vision: 这个模块提供了图像相关的数据处理和增强功能。
    • text: 这个模块提供了文本数据处理的功能。
  5. 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')
  1. download** 函数**:
    • url: 数据集的下载链接。
    • “./”: 下载文件的保存路径，这里表示当前目录。
    • kind=“zip”: 指定下载的文件类型为ZIP压缩文件。
    • replace=True: 如果目标路径已存在同名文件，则替换它。
  2. MnistDataset** 类**:
    • ‘MNIST_Data/train’: 指定MNIST训练数据集的路径。这个路径是基于下载和解压后的文件结构。

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

image, label = next(train_dataset.create_tuple_iterator())
print(image.shape)
  1. train_dataset.create_tuple_iterator():
    • create_tuple_iterator: 这是一个数据集方法，用于创建一个迭代器，该迭代器可以逐个返回数据集中的元素。每个元素是一个元组，包含图像和对应的标签。
  2. next** 函数**:
    • next: 这是一个内置函数，用于从迭代器中获取下一个元素。在这里，它获取训练数据集中的第一个元素，即一个图像和对应的标签。
  3. 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)
  1. transforms.Compose:
    • Compose: 这是一个组合多个数据增强操作的类。它接收一个操作序列，并将其组合成单个操作。这样可以在数据集上一次性应用多个增强操作。
  2. 数据增强操作序列:
    • 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)。这是为了适应一些深度学习模型的输入要求。
  3. train_dataset.map:
    • map: 这是一个数据集方法，用于对数据集中的每个元素应用指定的操作。参数 composed 指定要应用的操作，'image' 指定要应用操作的列（这里是图像列）。
  4. train_dataset.create_tuple_iterator():
    • create_tuple_iterator: 这是一个数据集方法，用于创建一个迭代器，该迭代器可以逐个返回数据集中的元素。每个元素是一个元组，包含图像和对应的标签。
  5. next** 函数**:
    • next: 这是一个内置函数，用于从迭代器中获取下一个元素。在这里，它获取训练数据集中的第一个元素，即一个图像和对应的标签。
  6. 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)
  1. numpy.random.randint:
    • randint: 这是一个NumPy函数，用于生成指定范围内的随机整数。这里生成一个48x48的图像，像素值在[0, 255]之间。
  2. Image.fromarray:
    • fromarray: 这是PIL库中的一个函数，用于将NumPy数组转换为PIL图像对象。
  3. 打印生成的随机图像的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)
  1. vision.Rescale:
    • Rescale: 这是MindSpore的vision模块中的一个变换，用于调整图像像素值的大小。参数 1.0 / 255.0 是缩放因子，0 是平移因子。
  2. 应用Rescale变换:
    • rescale(random_image): 将Rescale变换应用到生成的PIL图像上，返回缩放后的图像。
  3. 打印缩放后的图像:
    • 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)
  1. vision.Rescale:
    • Rescale: 这是MindSpore的vision模块中的一个变换，用于调整图像像素值的大小。参数 1.0 / 255.0 是缩放因子，0 是平移因子。
  2. 应用Rescale变换:
    • rescale(random_image): 将Rescale变换应用到生成的PIL图像上，返回缩放后的图像。需要注意的是，rescale 变换期望输入是一个NumPy数组，而不是PIL图像对象。因此，这段代码可能会抛出错误。
  3. 打印缩放后的图像:
    • 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)
  1. vision.Normalize:
    • Normalize: 这是MindSpore的vision模块中的一个变换，用于对图像进行归一化处理。参数 mean 和 std 分别是图像每个通道的均值和标准差。在这个例子中，mean 和 std 都是单元素元组，适用于单通道图像（例如灰度图像）。
  2. 应用Normalize变换:
    • normalize(rescaled_image): 将Normalize变换应用到缩放后的图像上，返回归一化后的图像。归一化的计算公式为 output_c = (input_c - mean_c) / std_c，其中 c 代表通道索引。
  3. 打印归一化后的图像:
    • 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)
  1. np.expand_dims:
    • np.expand_dims(normalized_image, -1): 在最后一个维度上扩展维度，将单通道图像转换为HWC格式（高度、宽度、通道）。这样，hwc_image 的形状将从 (48, 48) 变为 (48, 48, 1)。
  2. vision.HWC2CHW:
    • HWC2CHW: 这是MindSpore的vision模块中的一个变换，用于将图像从HWC格式（高度、宽度、通道）转换为CHW格式（通道、高度、宽度）。
  3. 应用HWC2CHW变换:
    • hwc2chw(hwc_image): 将HWC2CHW变换应用到 hwc_image 上，返回CHW格式的图像。这样，chw_image 的形状将从 (48, 48, 1) 变为 (1, 48, 48)。
  4. 打印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)
  1. GeneratorDataset:
    • GeneratorDataset: 这是MindSpore的一个数据集类，用于从一个生成器函数创建数据集。source 是生成器函数，column_names 是数据集的列名。
  2. 定义数据生成器:
    • text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
  3. 创建文本数据集:
    • texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
    • test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
  4. 打印数据集中的数据:
    • 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()))
  1. 定义数据生成器:
    • text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
  2. 创建文本数据集:
    • texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
    • test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
  3. 定义自定义分词器:
    • my_tokenizer(content): 这是一个简单的分词器函数，使用 split() 方法将输入文本按空格分割成单词列表。
  4. 应用自定义分词器:
    • test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=[‘text’]): 使用 map 方法将自定义分词器应用到数据集的 text 列。text.PythonTokenizer 是一个MindSpore的API，用于将Python函数包装成分词器。
  5. 打印数据集中的数据:
    • 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()))
  1. 定义数据生成器:
    • text_generator(data): 这是一个生成器函数，接受一个包含文本数据的列表作为输入。它使用 yield 返回每个文本数据。
  2. 创建文本数据集:
    • texts = [‘Welcome to Beijing’]: 定义一个包含文本数据的列表。
    • test_dataset = GeneratorDataset(source=text_generator(texts), column_names=[‘text’]): 使用 text_generator 和指定的列名创建一个 GeneratorDataset 数据集。
  3. 定义自定义分词器:
    • my_tokenizer(content): 这是一个简单的分词器函数，使用 split() 方法将输入文本按空格分割成单词列表。
  4. 应用自定义分词器:
    • test_dataset = test_dataset.map(operations=text.PythonTokenizer(my_tokenizer), input_columns=[‘text’]): 使用 map 方法将自定义分词器应用到数据集的 text 列。text.PythonTokenizer 是一个MindSpore的API，用于将Python函数包装成分词器。
  5. 创建词汇表:
    • vocab = Vocab.from_dataset(test_dataset, columns=[‘text’]): 从数据集的指定列创建一个词汇表 Vocab 对象。
  6. 打印词汇表:
    • print(vocab.vocab()): 打印词汇表，显示词汇和其索引。
  7. 使用词汇表映射文本数据:
    • test_dataset = test_dataset.map(operations=text.Lookup(vocab), input_columns=[‘text’]): 使用 map 方法将 text.Lookup 操作应用到数据集的 text 列，将文本数据映射为词汇索引。
  8. 打印数据集中的数据:
    • 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()))
  1. 创建数据集:
    • test_dataset = GeneratorDataset([1, 2, 3], ‘data’, shuffle=False): 使用 GeneratorDataset 创建一个数据集，数据源是一个包含 [1, 2, 3] 的列表，列名为 'data'，并且不进行洗牌操作。
  2. 应用映射操作:
    • test_dataset = test_dataset.map(operations=lambda x: x * 2): 使用 map 方法将一个匿名函数 lambda x: x * 2 应用到数据集的每一项数据上，将每个数据乘以 2。
  3. 打印数据集中的数据:
    • 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()))

s

  1. 定义函数:
    • func(x): 这是一个简单的函数，接受一个输入 x，返回 x 的平方加上 2。
  2. 创建数据集:
    • test_dataset = GeneratorDataset([1, 2, 3], ‘data’, shuffle=False): 使用 GeneratorDataset 创建一个数据集，数据源是一个包含 [1, 2, 3] 的列表，列名为 'data'，并且不进行洗牌操作。
  3. 应用映射操作:
    • test_dataset = test_dataset.map(operations=lambda x: func(x)): 使用 map 方法将一个匿名函数 lambda x: func(x) 应用到数据集的每一项数据上，调用 func 函数对每个数据进行处理。
  4. 打印数据集中的数据:
    • 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 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')

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 + 2

test_dataset = test_dataset.map(lambda x: func(x))
print(list(test_dataset.create_tuple_iterator()))
  1. 导入必要的库和模块：
    • numpy：用于数值计算。
    • PIL.Image：用于图像处理。
    • download：用于下载数据集。
    • mindspore.dataset：包含数据处理和变换的模块。
  2. 下载和加载数据集：
    • 使用download函数下载MNIST数据集并解压。
    • 使用MnistDataset加载训练数据集。
  3. 数据变换：
    • Compose：组合多个变换操作。
    • Rescale：调整图像像素值的大小。
    • Normalize：对图像进行归一化处理。
    • HWC2CHW：转换图像格式从HWC到CHW。
  4. 图像变换示例：
    • 生成随机图像并应用Rescale和Normalize变换。
    • 使用HWC2CHW变换转换图像格式。
  5. 文本变换示例：
    • 使用PythonTokenizer进行分词。
    • 使用Vocab生成词表并应用Lookup变换。
  6. Lambda变换示例：
    • 使用简单的Lambda函数对数据进行变换。
    • 定义复杂函数并使用Lambda函数进行变换。
  • mindspore.dataset.transforms.Compose：将多个变换操作组合成单个操作。
  • mindspore.dataset.vision.Rescale：调整图像像素值的大小。
  • mindspore.dataset.vision.Normalize：对图像进行归一化处理。
  • mindspore.dataset.vision.HWC2CHW：转换图像格式从HWC到CHW。
  • mindspore.dataset.text.PythonTokenizer：使用自定义函数进行分词。
  • mindspore.dataset.text.Vocab：生成词表。
  • mindspore.dataset.text.Lookup：将Token转换为Index。
  • mindspore.dataset.GeneratorDataset：从生成器创建数据集。
  • mindspore.dataset.MnistDataset：加载MNIST数据集。
  • mindspore.dataset.map：对数据集应用变换操作。
阅读全部

相关推荐

最近更新

  3. docker php8.1+nginx base 镜像 dockerfile 配置

    2024-07-15 01:10:04       67 阅读

  4. Could not load dynamic library ‘cudart64_100.dll‘

    2024-07-15 01:10:04       71 阅读

  9. 在Django里面运行非项目文件

    2024-07-15 01:10:04       58 阅读

  19. Python语言-面向对象

    2024-07-15 01:10:04       69 阅读

  20. 如何分清楚常见的 Git 分支管理策略Git Flow、GitHub Flow 和 GitLab Flow

    2024-07-15 01:10:04       64 阅读

热门阅读

  1. 免杀中用到的工具

    2024-07-15 01:10:04       18 阅读

  5. 【FPGA】Verilog 中 typedef enum 用法教程

    2024-07-15 01:10:04       18 阅读

  12. React@16.x（58）Redux@4.x（7）- 实现 combineReducers

    2024-07-15 01:10:04       21 阅读

  14. ECS中postTransform.Value = float4x4.Scale(1, math.sin(elapsedTime), 1)

    2024-07-15 01:10:04       19 阅读

  15. springsecurity01

    2024-07-15 01:10:04       15 阅读

  16. this指向解析

    2024-07-15 01:10:04       22 阅读

  17. AI究竟是在帮助开发者还是取代他们？

    2024-07-15 01:10:04       20 阅读

  18. C语言 判断素数

    2024-07-15 01:10:04       19 阅读

  25. ios CCRectangleBlock.m

    2024-07-15 01:10:04       17 阅读

  27. Spring之常见注解

    2024-07-15 01:10:04       19 阅读

  28. Golang 后端面经

    2024-07-15 01:10:04       21 阅读

  29. 印度标普基金关门，继续套利美元债LOF

    2024-07-15 01:10:04       20 阅读

  30. 基于深度学习的点云平滑

    2024-07-15 01:10:04       19 阅读