{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# 数据操作/数据变换\n", "\n", "[![下载Notebook](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/br_base/resource/_static/logo_notebook.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/br_base/tutorials/zh_cn/dataset/mindspore_eager.ipynb) [![下载样例代码](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/br_base/resource/_static/logo_download_code.svg)](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/br_base/tutorials/zh_cn/dataset/mindspore_eager.py) [![查看源文件](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/br_base/resource/_static/logo_source.svg)](https://gitee.com/mindspore/docs/blob/br_base/tutorials/source_zh_cn/dataset/eager.ipynb)\n" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 数据操作\n", "\n", "`mindspore.dataset` 提供了一系列数据集操作,用户可通过这些操作(如 [.shuffle](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/dataset_method/operation/mindspore.dataset.Dataset.shuffle.html#mindspore.dataset.Dataset.shuffle) 、 [.filter](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/dataset_method/operation/mindspore.dataset.Dataset.filter.html#mindspore.dataset.Dataset.filter) 、 [.skip](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/dataset_method/operation/mindspore.dataset.Dataset.skip.html#mindspore.dataset.Dataset.skip) 、 [.take](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/dataset_method/operation/mindspore.dataset.Dataset.take.html#mindspore.dataset.Dataset.take) 、 [.batch](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/dataset_method/batch/mindspore.dataset.Dataset.batch.html#mindspore.dataset.Dataset.batch) 等)实现数据集的混洗、过滤、跳过、批处理组合等功能。\n", "\n", "常用数据变换操作包括:\n", "\n", "- `.filter(...)`:通过指定条件,对数据进行过滤,保留满足预期条件的样本。\n", "- `.project(...)`:对多个数据列进行排序,或删除不需要的数据列。\n", "- `.rename(...)`:对指定数据列进行重命名,便于标记数据特性。\n", "- `.shuffle(...)`:划分一个数据缓冲区,对缓冲区内的数据进行混洗。\n", "- `.skip(...)`:跳过数据集的前n条样本。\n", "- `.take(...)`:只获取数据集的前n条样本。\n", "- `.map(...)`:通过自定义方法对每个样本进行变换和增强。\n", "- `.batch(...)`:对 `batch_size` 条数据进行组合。" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "下面将通过示例代码展示filter、skip、batch数据操作。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "filtered_dataset [[Tensor(shape=[], dtype=Int64, value= 1)], [Tensor(shape=[], dtype=Int64, value= 2)], [Tensor(shape=[], dtype=Int64, value= 3)]]\n", "skipped_dataset [[Tensor(shape=[], dtype=Int64, value= 4)], [Tensor(shape=[], dtype=Int64, value= 5)], [Tensor(shape=[], dtype=Int64, value= 6)]]\n", "batched_dataset [[Tensor(shape=[2], dtype=Int64, value= [1, 2])], [Tensor(shape=[2], dtype=Int64, value= [3, 4])], [Tensor(shape=[2], dtype=Int64, value= [5, 6])]]\n" ] } ], "source": [ "from mindspore.dataset import GeneratorDataset\n", "\n", "# Random-accessible object as input source\n", "class MyDataset:\n", " def __init__(self):\n", " self._data = [1, 2, 3, 4, 5, 6]\n", " def __getitem__(self, index):\n", " return self._data[index]\n", " def __len__(self):\n", " return len(self._data)\n", "\n", "loader = MyDataset()\n", "\n", "# find sampler which value < 4\n", "dataset = GeneratorDataset(source=loader, column_names=[\"data\"], shuffle=False)\n", "filtered_dataset = dataset.filter(lambda x: x < 4, input_columns=[\"data\"])\n", "print(\"filtered_dataset\", list(filtered_dataset))\n", "\n", "# skip dirst 3 samples\n", "dataset = GeneratorDataset(source=loader, column_names=[\"data\"], shuffle=False)\n", "skipped_dataset = dataset.skip(3)\n", "print(\"skipped_dataset\", list(skipped_dataset))\n", "\n", "# batch the dataset by batch_size=2\n", "dataset = GeneratorDataset(source=loader, column_names=[\"data\"], shuffle=False)\n", "batched_dataset = dataset.batch(2, num_parallel_workers=1)\n", "print(\"batched_dataset\", list(batched_dataset))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "除此之外,还支持数据集组合、切分、保存等操作。\n", "\n", "### 数据集组合\n", "\n", "数据集组合可以将多个数据集以串联/并朕的方式组合起来,形成一个全新的dataset对象。" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 2)}\n", "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 3)}\n", "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 1)}\n", "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 5)}\n", "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 6)}\n", "concated dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 4)}\n", "zipped dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 2), 'column_2': Tensor(shape=[], dtype=Int64, value= 5)}\n", "zipped dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 3), 'column_2': Tensor(shape=[], dtype=Int64, value= 6)}\n", "zipped dataset {'column_1': Tensor(shape=[], dtype=Int64, value= 1), 'column_2': Tensor(shape=[], dtype=Int64, value= 4)}\n" ] } ], "source": [ "import mindspore.dataset as ds\n", "\n", "ds.config.set_seed(1234)\n", "\n", "# concat same column of two datasets\n", "data = [1, 2, 3]\n", "dataset1 = ds.NumpySlicesDataset(data=data, column_names=[\"column_1\"])\n", "\n", "data = [4, 5, 6]\n", "dataset2 = ds.NumpySlicesDataset(data=data, column_names=[\"column_1\"])\n", "\n", "dataset = dataset1.concat(dataset2)\n", "for item in dataset.create_dict_iterator():\n", " print(\"concated dataset\", item)\n", "\n", "\n", "# zip different columns of two datasets\n", "data = [1, 2, 3]\n", "dataset1 = ds.NumpySlicesDataset(data=data, column_names=[\"column_1\"])\n", "\n", "data = [4, 5, 6]\n", "dataset2 = ds.NumpySlicesDataset(data=data, column_names=[\"column_2\"])\n", "\n", "dataset = dataset1.zip(dataset2)\n", "for item in dataset.create_dict_iterator():\n", " print(\"zipped dataset\", item)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### 数据集切分\n", "\n", "将数据集切分成训练集和验证集,分别用于训练和验证过程。" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ ">>>> train dataset >>>>\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 6)}\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 4)}\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 1)}\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 5)}\n", ">>>> eval dataset >>>>\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 3)}\n", "{'column_1': Tensor(shape=[], dtype=Int64, value= 2)}\n" ] } ], "source": [ "import mindspore.dataset as ds\n", "\n", "data = [1, 2, 3, 4, 5, 6]\n", "dataset = ds.NumpySlicesDataset(data=data, column_names=[\"column_1\"], shuffle=False)\n", "\n", "train_dataset, eval_dataset = dataset.split([4, 2])\n", "\n", "print(\">>>> train dataset >>>>\")\n", "for item in train_dataset.create_dict_iterator():\n", " print(item)\n", "\n", "print(\">>>> eval dataset >>>>\")\n", "for item in eval_dataset.create_dict_iterator():\n", " print(item)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### 数据集保存\n", "\n", "将数据集重新保存为MindRecord数据格式。" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [], "source": [ "import os\n", "import mindspore.dataset as ds\n", "\n", "ds.config.set_seed(1234)\n", "\n", "data = [1, 2, 3, 4, 5, 6]\n", "dataset = ds.NumpySlicesDataset(data=data, column_names=[\"column_1\"])\n", "\n", "if os.path.exists(\"./train_dataset.mindrecord\"):\n", " os.remove(\"./train_dataset.mindrecord\")\n", "if os.path.exists(\"./train_dataset.mindrecord.db\"):\n", " os.remove(\"./train_dataset.mindrecord.db\")\n", "\n", "dataset.save(\"./train_dataset.mindrecord\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 数据变换\n", "\n", "通常情况下,直接加载的原始数据无法直接用于神经网络训练,此时我们需要对其进行数据预处理。\n", "\n", "MindSpore提供多种数据变换(Transforms)操作,可结合数据处理Pipeline实现预处理。\n", "\n", "这些变换通常有2种使用方法,分别为“基于数据操作map进行数据变换”和“轻量化数据变换”,下面分别进行介绍。" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### 基于`map`数据操作进行数据变换\n", "\n", "- `mindspore.dataset` 提供面向图像、文本、音频等不同数据类型的内置数据变换操作,所有变换均可传递给 `map` 操作,通过 `map` 方法自动对每个样本进行变换。\n", "- 除了内置的数据变换外,`map` 操作也支持执行用户自定义的变换操作。\n" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/MNIST_Data.zip (10.3 MB)\n", "\n", "file_sizes: 100%|██████████████████████████| 10.8M/10.8M [00:01<00:00, 6.99MB/s]\n", "Extracting zip file...\n", "Successfully downloaded / unzipped to ./\n", "(64, 64, 1) UInt8\n" ] } ], "source": [ "# Download data from open datasets\n", "from download import download\n", "from mindspore.dataset import MnistDataset\n", "import mindspore.dataset.vision as vision\n", "\n", "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/\" \\\n", " \"notebook/datasets/MNIST_Data.zip\"\n", "path = download(url, \"./\", kind=\"zip\", replace=True)\n", "\n", "# create MNIST loader\n", "train_dataset = MnistDataset(\"MNIST_Data/train\", shuffle=False)\n", "\n", "# resize samples to (64, 64) using built-in transformation\n", "train_dataset = train_dataset.map(operations=[vision.Resize((64, 64))],\n", " input_columns=['image'])\n", "\n", "for data in train_dataset:\n", " print(data[0].shape, data[0].dtype)\n", " break" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(28, 28, 1) Float64\n" ] } ], "source": [ "# create MNIST loader\n", "train_dataset = MnistDataset(\"MNIST_Data/train\", shuffle=False)\n", "\n", "def transform(img):\n", " img = img / 255.0\n", " return img\n", "\n", "# apply normalize using customized transformation\n", "train_dataset = train_dataset.map(operations=[transform],\n", " input_columns=['image'])\n", "\n", "for data in train_dataset:\n", " print(data[0].shape, data[0].dtype)\n", " break" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### 轻量化数据变换\n", "\n", "MindSpore提供一种轻量化的数据处理方式,称为Eager模式。\n", "\n", "在Eager模式下,Transforms以函数式调用的方式执行,代码更为简洁,且能立即获得运行结果。推荐在小型数据变换实验、模型推理等轻量化场景中使用。\n", "\n", "![eagermode1](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/br_base/tutorials/source_zh_cn/dataset/images/eager_mode.jpeg)\n", "\n", "MindSpore目前支持在Eager模式执行各种Transform,具体如下所示,更多数据变换接口参见API文档。\n", "\n", "- [vision模块](https://mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.transforms.html#视觉),基于OpenCV/Pillow实现的数据变换。\n", "\n", "- [text模块](https://mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.transforms.html#文本),基于Jieba/ICU4C等库实现的数据变换。\n", "\n", "- [audio模块](https://mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.transforms.html#音频),基于C++实现的数据变换。\n", "\n", "- [transforms模块](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.transforms.html#通用),基于C++/Python/NumPy实现的通用数据变换。\n", "\n", "下面简要介绍各Transforms模块的Eager模式使用方法。使用Eager模式,只需要将Transform当成可执行函数调用即可。" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 数据准备\n", "\n", "以下示例代码将图片数据下载到指定路径。" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/banana.jpg (17 kB)\n", "\n", "file_sizes: 100%|██████████████████████████| 17.1k/17.1k [00:00<00:00, 2.14MB/s]\n", "Successfully downloaded file to ./banana.jpg\n" ] }, { "data": { "text/plain": [ "'./banana.jpg'" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" } ], "source": [ "from download import download\n", "\n", "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/banana.jpg\"\n", "download(url, './banana.jpg', replace=True)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### vision\n", "\n", "此示例将使用`mindspore.dataset.vision`模块中的Transform,对给定图像进行变换。\n", "\n", "Vision Transform的Eager模式支持`numpy.array`或`PIL.Image`类型数据作为入参。更多示例请参考:[样例库](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/samples/dataset/vision_gallery.html)" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Image.type: , Image.shape: (356, 200)\n", "Image.type: , Image.shape: (569, 320)\n", "Image.type: , Image.shape: (280, 280)\n", "Image.type: , Image.shape: (360, 360)\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "from PIL import Image\n", "import matplotlib.pyplot as plt\n", "import mindspore.dataset.vision as vision\n", "\n", "img_ori = Image.open(\"banana.jpg\").convert(\"RGB\")\n", "print(\"Image.type: {}, Image.shape: {}\".format(type(img_ori), img_ori.size))\n", "\n", "# Apply Resize to input immediately\n", "op1 = vision.Resize(size=(320))\n", "img = op1(img_ori)\n", "print(\"Image.type: {}, Image.shape: {}\".format(type(img), img.size))\n", "\n", "# Apply CenterCrop to input immediately\n", "op2 = vision.CenterCrop((280, 280))\n", "img = op2(img)\n", "print(\"Image.type: {}, Image.shape: {}\".format(type(img), img.size))\n", "\n", "# Apply Pad to input immediately\n", "op3 = vision.Pad(40)\n", "img = op3(img)\n", "print(\"Image.type: {}, Image.shape: {}\".format(type(img), img.size))\n", "\n", "# Show the result\n", "plt.subplot(1, 2, 1)\n", "plt.imshow(img_ori)\n", "plt.title(\"original image\")\n", "plt.subplot(1, 2, 2)\n", "plt.imshow(img)\n", "plt.title(\"transformed image\")\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### text\n", "\n", "此示例将使用`text`模块中的Transforms,对给定文本进行变换。\n", "\n", "Text Transforms的Eager模式支持`numpy.array`类型数据作为入参。更多示例请参考:[样例库](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/samples/dataset/text_gallery.html)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Tokenize result: ['W' 'e' 'l' 'c' 'o' 'm' 'e' ' ' 't' 'o' ' ' 'B' 'e' 'i' 'j' 'i' 'n' 'g'\n", " ' ' '!']\n", "ToNumber result: [123456], type: int32\n" ] } ], "source": [ "import mindspore.dataset.text.transforms as text\n", "import mindspore as ms\n", "\n", "# Apply UnicodeCharTokenizer to input immediately\n", "txt = \"Welcome to Beijing !\"\n", "txt = text.UnicodeCharTokenizer()(txt)\n", "print(\"Tokenize result: {}\".format(txt))\n", "\n", "# Apply ToNumber to input immediately\n", "txt = [\"123456\"]\n", "to_number = text.ToNumber(ms.int32)\n", "txt = to_number(txt)\n", "print(\"ToNumber result: {}, type: {}\".format(txt, txt[0].dtype))" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### audio\n", "\n", "此示例将使用`audio`模块中的Transforms,对给定音频进行变换。\n", "\n", "Audio Transforms的Eager模式支持`numpy.array`类型数据作为入参。更多示例请参考:[样例库](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/samples/dataset/audio_gallery.html)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Downloading data from https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/84-121123-0000.wav (65 kB)\n", "\n", "file_sizes: 100%|███████████████████████████| 67.0k/67.0k [00:00<00:00, 756kB/s]\n", "Successfully downloaded file to ./84-121123-0000.wav\n" ] } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "import scipy.io.wavfile as wavfile\n", "from download import download\n", "\n", "import mindspore.dataset as ds\n", "import mindspore.dataset.audio as audio\n", "\n", "ds.config.set_seed(5)\n", "\n", "# citation: LibriSpeech http://www.openslr.org/12\n", "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/84-121123-0000.wav\"\n", "download(url, './84-121123-0000.wav', replace=True)\n", "wav_file = \"84-121123-0000.wav\"\n", "\n", "def plot_waveform(waveform, sr, title=\"Waveform\"):\n", " if waveform.ndim == 1:\n", " waveform = waveform[np.newaxis, :]\n", " num_channels, num_frames = waveform.shape\n", " time_axis = np.arange(0, num_frames) / sr\n", "\n", " figure, axes = plt.subplots(num_channels, 1)\n", " axes.plot(time_axis, waveform[0], linewidth=1)\n", " axes.grid(True)\n", " figure.suptitle(title)\n", " plt.show(block=False)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "BassBiquad 对输入的音频信号执行双极低搁架滤波(two-pole low-shelf filter)。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "sample_rate, waveform = wavfile.read(wav_file)\n", "\n", "bass_biquad = audio.BassBiquad(sample_rate, 10.0)\n", "transformed_waveform = bass_biquad(waveform.astype(np.float32))\n", "plot_waveform(transformed_waveform, sample_rate, title=\"BassBiquad Waveform\")" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### transforms\n", "\n", "此示例将使用`transforms`模块中的通用Transform,对给定数据进行变换。\n", "\n", "通用Transform的Eager模式支持`numpy.array`类型数据作为入参。" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Fill result: [0 0 0 0 0]\n", "OneHot result: [0 0 1 0 0]\n" ] } ], "source": [ "import numpy as np\n", "import mindspore.dataset.transforms as trans\n", "\n", "# Apply Fill to input immediately\n", "data = np.array([1, 2, 3, 4, 5])\n", "fill = trans.Fill(0)\n", "data = fill(data)\n", "print(\"Fill result: \", data)\n", "\n", "# Apply OneHot to input immediately\n", "label = np.array(2)\n", "onehot = trans.OneHot(num_classes=5)\n", "label = onehot(label)\n", "print(\"OneHot result: \", label)" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3.7.5 64-bit", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.10.16" }, "vscode": { "interpreter": { "hash": "5109d816b82be14675a6b11f8e0f0d2e80f029176ed3710d54e125caa8520dfd" } } }, "nbformat": 4, "nbformat_minor": 4 }