导入数据集相关库和类
首先,导入了 NumPy 库,并将其简称为 np 。要知道,NumPy 乃是用于科学计算的关键库,作用非凡。接着,从 mindspore.dataset 当中导入了 vision 模块。此外,还从 mindspore.dataset 里引入了 MnistDataset 和 GeneratorDataset 这两个与数据集紧密相关的类。最后,导入了 matplotlib 库的 pyplot 模块,并简称为 plt ,其主要用于实现数据的可视化。
代码如下:
import numpy as np from mindspore.dataset import vision from mindspore.dataset import MnistDataset, GeneratorDataset import matplotlib.pyplot as plt
数据集加载
首先是从开放数据集去下载数据,随后导入了一个叫“download”的功能模块或者函数。接下来,设定了一个字符串变量“url”,这个“url”代表着要下载的数据所在的网址。最后呢,调用“download”这个函数来下载“url”所指定的那些数据,并且把数据存放到当前的目录(“./”)当中。要注意哦,下载的这些数据是压缩文件(zip 格式的),要是本地已经有相同的文件了,那就会进行替换操作。
代码如下:
# Download data from open datasets
from download import download
url = "https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/" \ "notebook/datasets/MNIST_Data.zip"
path = download(url, "./", kind="zip", replace=True)
运行结果:
创建了一个名为 train_dataset 的数据集对象,该数据集是基于“MNIST_Data/train”路径下的数据创建的 MnistDataset 类型,并且设置了不进行随机打乱(shuffle=False)。然后,打印出 train_dataset 的数据类型。
代码如下:
train_dataset = MnistDataset("MNIST_Data/train", shuffle=False)
print(type(train_dataset))
运行结果:
<class 'mindspore.dataset.engine.datasets_vision.MnistDataset'>
数据集迭代
数据集加载后,一般以迭代方式获取数据,然后送入神经网络中进行训练。我们可以用create_tuple_iterator或create_dict_iterator接口创建数据迭代器,迭代访问数据。
访问的数据类型默认为Tensor;若设置output_numpy=True,访问的数据类型为Numpy。
以下定义了一个用于可视化的函数,其旨在对 9 张图片进行迭代展示。此函数的目的在于以 3x3 的布局对数据集中的图像及其对应的标签予以可视化呈现。
代码如下:
def visualize(dataset): #创建一个大小为 4x4 的图形窗口。 figure = plt.figure(figsize=(4, 4)) #定义了子图的列数和行数,均为 3。 cols, rows = 3, 3 #调整子图之间的水平间距(wspace)和垂直间距(hspace)为 0.5 。 plt.subplots_adjust(wspace=0.5, hspace=0.5) #通过枚举数据集的迭代器,获取图像和标签。 for idx, (image, label) in enumerate(dataset.create_tuple_iterator()): #在图形中添加一个子图,位置由当前的索引决定。 figure.add_subplot(rows, cols, idx + 1) #为子图设置标题,标题内容为标签的整数形式。 plt.title(int(label)) #关闭坐标轴的显示。 plt.axis("off") #在子图中显示图像,使用灰度颜色映射(cmap="gray")。 plt.imshow(image.asnumpy().squeeze(), cmap="gray") #当达到 9 个(3x3)子图时,停止循环。 if idx == cols * rows - 1: break #显示图形窗口,展示所有的子图。 plt.show()
调用名为 visualize 的函数,并将 train_dataset 作为参数传递给这个函数进行可视化展示。
代码如下:
visualize(train_dataset)
运行结果:(随机)
数据集的常用操作
shuffle
数据集随机shuffle可以消除数据排列造成的分布不均问题。
首先,对名为 train_dataset 的数据集进行打乱操作,打乱时使用的缓冲区大小为 64。然后,调用 visualize 函数,并将打乱后的 train_dataset 作为参数传递给这个函数,以进行相应的可视化展示。
代码如下:
train_dataset = train_dataset.shuffle(buffer_size=64)
visualize(train_dataset)
运行结果:(随机)
map
map操作是数据预处理的关键操作,可以针对数据集指定列(column)添加数据变换(Transforms),将数据变换应用于该列数据的每个元素,并返回包含变换后元素的新数据集。
对数据集 train_dataset 中的数据进行处理和输出信息。
首先,通过 next(train_dataset.create_tuple_iterator()) 获取数据集中的一组数据(图像 image 和标签 label),然后打印出图像的形状和数据类型。接着,使用 map 方法对数据集中的 'image' 列应用 vision.Rescale(1.0 / 255.0, 0) 这个缩放操作,将图像的像素值缩放到 0 到 1 之间。最后,再次获取一组经过缩放处理后的数据,并打印出此时图像的形状和数据类型,以查看缩放操作的效果。
代码如下:
image, label = next(train_dataset.create_tuple_iterator())
print(image.shape, image.dtype)
train_dataset = train_dataset.map(vision.Rescale(1.0 / 255.0, 0), input_columns='image')
image, label = next(train_dataset.create_tuple_iterator())
print(image.shape, image.dtype)
运行结果:
(28, 28, 1) UInt8
(28, 28, 1) Float32
batch
将数据集打包为固定大小的batch是在有限硬件资源下使用梯度下降进行模型优化的折中方法,可以保证梯度下降的随机性和优化计算量。
代码如下:
train_dataset = train_dataset.batch(batch_size=32)
image, label = next(train_dataset.create_tuple_iterator())
print(image.shape, image.dtype)
分析:
首先,train_dataset = train_dataset.batch(batch_size=32) 这行代码将数据集 train_dataset 按照每个批次 32 个样本进行分组。
然后,通过 next(train_dataset.create_tuple_iterator()) 获取经过批次处理后的数据集的一组数据(图像 image 和标签 label)。
最后,打印出获取到的这组图像数据的形状和数据类型。
运行结果:
(32, 28, 28, 1) Float32
自定义数据集
可随机访问数据集
定义了一个名为 RandomAccessDataset 的类,其作用是创建一个可随机访问的数据集对象。
__init__ 方法:这是类的初始化方法。在创建 RandomAccessDataset 对象时会被调用。它初始化了两个 NumPy 数组 _data 和 _label ,_data 是一个 5 行 2 列的全 1 数组,_label 是一个 5 行 1 列的全 0 数组。
__getitem__ 方法:这个方法使得对象可以通过索引(index)来获取数据。当通过索引访问对象时(如 obj[index]),会调用这个方法,并返回指定索引处的 _data 和 _label 的值。
__len__ 方法:这个方法返回数据集的长度,即 _data 的长度(这里是 5)。它用于一些需要知道数据集大小的操作,例如在循环中。
代码如下:
# Random-accessible object as input source
class RandomAccessDataset: def __init__(self): self._data = np.ones((5, 2)) self._label = np.zeros((5, 1)) def __getitem__(self, index): return self._data[index], self._label[index] def __len__(self): return len(self._data)
创建了一个 RandomAccessDataset 类的实例 loader 。然后,使用这个实例 loader 作为数据源创建了一个 GeneratorDataset 对象 dataset ,并指定了列名为 ["data", "label"] 。最后,通过一个 for 循环遍历 dataset 中的数据,并打印每次循环得到的数据。
代码如下:
loader = RandomAccessDataset()
dataset = GeneratorDataset(source=loader, column_names=["data", "label"])
for data in dataset: print(data)
运行结果:
[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]
[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]
[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]
[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]
[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]
创建了一个名为 loader 的列表,其中包含三个 numpy 数组:np.array(0) 、np.array(1) 和 np.array(2) 。
接着使用 loader 作为数据源创建了一个名为 dataset 的 GeneratorDataset 对象,并指定列名为 ["data"] 。
最后通过一个 for 循环遍历 dataset 中的数据,并打印每次循环得到的数据。
代码如下:
# list, tuple are also supported.
loader = [np.array(0), np.array(1), np.array(2)]
dataset = GeneratorDataset(source=loader, column_names=["data"])
for data in dataset: print(data)
运行结果:
[Tensor(shape=[], dtype=Int64, value= 0)]
[Tensor(shape=[], dtype=Int64, value= 1)]
[Tensor(shape=[], dtype=Int64, value= 2)]
可迭代数据集
可迭代的数据集是实现了__iter__和__next__方法的数据集,表示可以通过迭代的方式逐步获取数据样本。这种类型的数据集特别适用于随机访问成本太高或者不可行的情况。
代码如下:
# Iterator as input source
class IterableDataset(): def __init__(self, start, end): '''''init the class object to hold the data''' self.start = start self.end = end def __next__(self): '''''iter one data and return''' return next(self.data) def __iter__(self): '''''reset the iter''' self.data = iter(range(self.start, self.end)) return self
分析:定义了一个名为 IterableDataset 的类。
__init__ 方法:用于初始化类的对象,接收 start 和 end 两个参数,用于表示数据的起始和结束范围。
__next__ 方法:每次迭代时取出一个数据并返回。但这里的实现存在问题,因为代码中没有定义 self.data ,直接使用 next(self.data) 会导致错误。正确的实现应该是从已经初始化的 self.data 中获取下一个元素。
__iter__ 方法:在每次迭代开始时,将 range(self.start, self.end) 转换为一个迭代器,并将其赋值给 self.data ,然后返回自身,使得该对象可用于迭代操作。
总的来说,这个类的目的是创建一个可迭代的数据集对象,能够在迭代时依次返回指定范围内的整数。但需要注意 __next__ 方法中对 self.data 的使用需要在前面进行正确的初始化。
创建了一个 IterableDataset 类的对象 loader ,其数据范围是从 1 到 5 。然后创建了一个 GeneratorDataset 对象 dataset ,将 loader 作为数据源,并指定了列名为 ["data"] 。最后通过一个 for 循环遍历 dataset 中的每个元素 d ,并将其打印出来。
代码如下:
loader = IterableDataset(1, 5)
dataset = GeneratorDataset(source=loader, column_names=["data"])
for d in dataset: print(d)
运行结果:
[Tensor(shape=[], dtype=Int64, value= 1)]
[Tensor(shape=[], dtype=Int64, value= 2)]
[Tensor(shape=[], dtype=Int64, value= 3)]
[Tensor(shape=[], dtype=Int64, value= 4)]
生成器
定义了一个名为 my_generator 的生成器函数,它接受 start 和 end 两个参数,通过 for 循环使用 yield 关键字依次生成从 start 到 end - 1 的整数。由于生成器实例只能被迭代一次,所以使用 lambda 表达式来包装 my_generator 函数,以便能够生成多个实例。然后创建了一个 GeneratorDataset 对象 dataset ,将这个包装后的函数作为数据源,并指定列名为 ["data"] 。最后通过 for 循环遍历 dataset 中的每个元素 d ,并将其打印出来。
代码如下:
# Generator
def my_generator(start, end): for i in range(start, end): yield i
# since a generator instance can be only iterated once, we need to wrap it by lambda to generate multiple instances
dataset = GeneratorDataset(source=lambda: my_generator(3, 6), column_names=["data"])
for d in dataset: print(d)
运行结果:
[Tensor(shape=[], dtype=Int64, value= 3)]
[Tensor(shape=[], dtype=Int64, value= 4)]
[Tensor(shape=[], dtype=Int64, value= 5)]
打印时间:
import time
print(time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()),'qianduanjidi')
运行截图: