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