{ "cells": [ { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "# 数据加载与采样" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "[![下载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_sampler.ipynb) \n", "[![下载样例代码](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_sampler.py) \n", "[![查看源文件](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/sampler.ipynb)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 数据加载\n", "\n", "数据是训练的基础,`mindspore.dataset` 模块提供了自定义方式加载数据集的API,也提供了常用公开数据集的加载类。\n", "\n", "### 自定义数据集\n", "\n", "MindSpore可以通过自定义数据加载类或自定义数据集生成函数的方式来生成数据集。然后通过[mindspore.dataset.GeneratorDataset](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/mindspore.dataset.GeneratorDataset.html)接口实现自定义方式的数据集加载。\n", "\n", "`GeneratorDataset` 支持通过可随机访问数据集对象、可迭代数据集对象和生成器(generator)构造自定义数据集,下面分别进行介绍。\n", "\n", "#### 可随机访问数据集\n", "\n", "可随机访问数据集是实现了 `__getitem__` 和 `__len__` 方法的数据集,表示可以通过索引/键直接访问对应位置的数据样本。\n", "\n", "例如,当使用 `dataset[idx]` 访问这样的数据集时,可以读取数据集中第 `idx` 个样本或标签。" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]\n", "[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]\n", "[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]\n", "[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]\n", "[Tensor(shape=[2], dtype=Float64, value= [ 1.00000000e+00, 1.00000000e+00]), Tensor(shape=[1], dtype=Float64, value= [ 0.00000000e+00])]\n" ] } ], "source": [ "import numpy as np\n", "from mindspore.dataset import GeneratorDataset\n", "\n", "# Random-accessible object as input source\n", "class RandomAccessDataset:\n", " def __init__(self):\n", " self._data = np.ones((5, 2))\n", " self._label = np.zeros((5, 1))\n", " def __getitem__(self, index):\n", " return self._data[index], self._label[index]\n", " def __len__(self):\n", " return len(self._data)\n", "\n", "loader = RandomAccessDataset()\n", "dataset = GeneratorDataset(source=loader, column_names=[\"data\", \"label\"])\n", "\n", "for data in dataset:\n", " print(data)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 可迭代数据集\n", "\n", "可迭代数据集是实现了 `__iter__` 和 `__next__` 方法的数据集,表示可以通过迭代的方式逐步获取数据样本。这种类型的数据集适用于随机访问成本较高或者不可行的场景。\n", "\n", "例如,当使用 `iter(dataset)` 访问数据集时,可以读取从数据库、远程服务器返回的数据流。\n", "\n", "下面构造一个简单迭代器,并将其加载至 `GeneratorDataset` 。" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[Tensor(shape=[], dtype=Int64, value= 1)]\n", "[Tensor(shape=[], dtype=Int64, value= 2)]\n", "[Tensor(shape=[], dtype=Int64, value= 3)]\n", "[Tensor(shape=[], dtype=Int64, value= 4)]\n" ] } ], "source": [ "# Iterator as input source\n", "class IterableDataset():\n", " def __init__(self, start, end):\n", " '''init the class object to hold the data'''\n", " self.start = start\n", " self.end = end\n", " def __next__(self):\n", " '''iter one data and return'''\n", " return next(self.data)\n", " def __iter__(self):\n", " '''reset the iter'''\n", " self.data = iter(range(self.start, self.end))\n", " return self\n", "\n", "loader = IterableDataset(1, 5)\n", "dataset = GeneratorDataset(source=loader, column_names=[\"data\"])\n", "\n", "for d in dataset:\n", " print(d)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "#### 生成器\n", "\n", "生成器也属于可迭代的数据集类型,其直接依赖Python的生成器类型 `generator` 返回数据,直至生成器抛出 `StopIteration` 异常。\n", "\n", "下面构造一个生成器,并将其加载至 `GeneratorDataset` 。" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[Tensor(shape=[], dtype=Int64, value= 3)]\n", "[Tensor(shape=[], dtype=Int64, value= 4)]\n", "[Tensor(shape=[], dtype=Int64, value= 5)]\n" ] } ], "source": [ "# Generator\n", "def my_generator(start, end):\n", " for i in range(start, end):\n", " yield i\n", "\n", "# since a generator instance can be only iterated once, we need to wrap it by lambda to generate multiple instances\n", "dataset = GeneratorDataset(source=lambda: my_generator(3, 6), column_names=[\"data\"])\n", "\n", "for d in dataset:\n", " print(d)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "### 常用公开数据集的加载\n", "\n", "MindSpore也支持开源经典数据集的解析和读取,如MNIST、CIFAR-10、CLUE、LJSpeech等。\n", "\n", "以MNIST数据集作为样例,更多其他数据集请参考 [开源数据集](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.loading.html#%E5%BC%80%E6%BA%90%E6%95%B0%E6%8D%AE%E9%9B%86%E5%8A%A0%E8%BD%BD) 。" ] }, { "cell_type": "code", "execution_count": 4, "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, 7.65MB/s]\n", "Extracting zip file...\n", "Successfully downloaded / unzipped to ./\n", "\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Download data from open datasets\n", "from download import download\n", "from mindspore.dataset import MnistDataset\n", "import matplotlib.pyplot as plt\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", "print(type(train_dataset))\n", "\n", "# visualize dataset content\n", "figure = plt.figure(figsize=(4, 4))\n", "cols, rows = 3, 3\n", "\n", "plt.subplots_adjust(wspace=0.5, hspace=0.5)\n", "\n", "for idx, (image, label) in enumerate(train_dataset.create_tuple_iterator()):\n", " figure.add_subplot(rows, cols, idx + 1)\n", " plt.title(int(label))\n", " plt.axis(\"off\")\n", " plt.imshow(image.asnumpy().squeeze(), cmap=\"gray\")\n", " if idx == cols * rows - 1:\n", " break\n", "plt.show()" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "## 采样器\n", "\n", "为满足训练需求,解决如数据集过大、样本类别分布不均等问题,MindSpore提供了多种不同用途的采样器(Sampler),帮助用户对数据集进行不同形式的采样。用户只需在加载数据集时传入采样器对象,即可实现数据采样。\n", "\n", "MindSpore目前提供了如[mindspore.dataset.RandomSampler](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/mindspore.dataset.RandomSampler.html)、[mindspore.dataset.WeightedRandomSampler](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/mindspore.dataset.WeightedRandomSampler.html)、[mindspore.dataset.SubsetRandomSampler](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/dataset/mindspore.dataset.SubsetRandomSampler.html)等多种采样器。此外,用户也可以根据需要实现自定义采样器类。\n", "\n", "> 更多采样器的使用方法参见[采样器API文档](https://www.mindspore.cn/docs/zh-CN/br_base/api_python/mindspore.dataset.loading.html#%E9%87%87%E6%A0%B7%E5%99%A8-1)。\n", "\n", "下面主要以CIFAR-10数据集为例,介绍几种常用MindSpore采样器的使用方法。\n", "\n", "![cifar10](https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/website-images/br_base/tutorials/source_zh_cn/dataset/images/cifar10.jpg)\n", "\n", "> 本章节中的示例代码依赖`matplotlib`,可使用命令`pip install matplotlib`安装。如本文档以Notebook运行时,完成安装后需要重启kernel才能执行后续代码。" ] }, { "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/cifar-10-binary.tar.gz (162.2 MB)\n", "\n", "file_sizes: 100%|████████████████████████████| 170M/170M [00:21<00:00, 7.85MB/s]\n", "Extracting tar.gz file...\n", "Successfully downloaded / unzipped to ./\n" ] } ], "source": [ "from download import download\n", "\n", "url = \"https://mindspore-website.obs.cn-north-4.myhuaweicloud.com/notebook/datasets/cifar-10-binary.tar.gz\"\n", "\n", "path = download(url, \"./\", kind=\"tar.gz\", replace=True)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "解压后数据集文件的目录结构如下:\n", "\n", "```text\n", ".\n", "└── cifar-10-batches-bin\n", " ├── batches.meta.txt\n", " ├── data_batch_1.bin\n", " ├── data_batch_2.bin\n", " ├── data_batch_3.bin\n", " ├── data_batch_4.bin\n", " ├── data_batch_5.bin\n", " ├── readme.html\n", " └── test_batch.bin\n", "```\n", "\n", "### RandomSampler\n", "\n", "从索引序列中随机采样指定数目的数据。\n", "\n", "下面的样例使用随机采样器,分别从数据集中有放回和无放回地随机采样5个数据,并打印展示。为了便于观察有放回与无放回的效果,这里自定义了一个数据量较小的数据集。" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "With Replacement: 1 4 5 8 7 \n", "Without Replacement: 1 6 7 4 3 " ] } ], "source": [ "from mindspore.dataset import RandomSampler, NumpySlicesDataset\n", "\n", "np_data = [1, 2, 3, 4, 5, 6, 7, 8] # 数据集\n", "\n", "# 定义有放回采样器,采样5条数据\n", "sampler1 = RandomSampler(replacement=True, num_samples=5)\n", "dataset1 = NumpySlicesDataset(np_data, column_names=[\"data\"], sampler=sampler1)\n", "\n", "print(\"With Replacement: \", end='')\n", "for data in dataset1.create_tuple_iterator(output_numpy=True):\n", " print(data[0], end=' ')\n", "\n", "# 定义无放回采样器,采样5条数据\n", "sampler2 = RandomSampler(replacement=False, num_samples=5)\n", "dataset2 = NumpySlicesDataset(np_data, column_names=[\"data\"], sampler=sampler2)\n", "\n", "print(\"\\nWithout Replacement: \", end='')\n", "for data in dataset2.create_tuple_iterator(output_numpy=True):\n", " print(data[0], end=' ')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印结果可以看出,使用有放回采样器时,同一条数据可能会被多次获取;使用无放回采样器时,同一条数据只能被获取一次。\n", "\n", "### WeightedRandomSampler\n", "\n", "指定长度为N的采样概率列表,按照概率在前N个样本中随机采样指定数目的数据。\n", "\n", "下面的样例使用带权随机采样器从CIFAR-10数据集的前10个样本中按概率获取6个样本,并展示已读取数据的形状和标签。" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Image shape: (32, 32, 3) , Label: 6\n", "Image shape: (32, 32, 3) , Label: 6\n", "Image shape: (32, 32, 3) , Label: 6\n", "Image shape: (32, 32, 3) , Label: 9\n", "Image shape: (32, 32, 3) , Label: 9\n", "Image shape: (32, 32, 3) , Label: 6\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import math\n", "import matplotlib.pyplot as plt\n", "from mindspore.dataset import WeightedRandomSampler, Cifar10Dataset\n", "%matplotlib inline\n", "\n", "DATA_DIR = \"./cifar-10-batches-bin/\"\n", "\n", "# 指定前10个样本的采样概率并进行采样\n", "weights = [0.8, 0.5, 0, 0, 0, 0, 0, 0, 0, 0]\n", "sampler = WeightedRandomSampler(weights, num_samples=6)\n", "dataset = Cifar10Dataset(DATA_DIR, sampler=sampler) # 加载数据\n", "\n", "def plt_result(dataset, row):\n", " \"\"\"显示采样结果\"\"\"\n", " num = 1\n", " for data in dataset.create_dict_iterator(output_numpy=True):\n", " print(\"Image shape:\", data['image'].shape, \", Label:\", data['label'])\n", " plt.subplot(row, math.ceil(dataset.get_dataset_size() / row), num)\n", " image = data['image']\n", " plt.imshow(image, interpolation=\"None\")\n", " num += 1\n", "\n", "plt_result(dataset, 2)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印结果可以看出,本次在10个样本中随机采样了6条数据,只有前面两个采样概率不为0的样本才有机会被采样。\n", "\n", "### SubsetRandomSampler\n", "\n", "从指定样本索引子序列中随机采样指定数目的样本数据。\n", "\n", "下面的样例使用子序列随机采样器从CIFAR-10数据集的指定子序列中抽样6个样本,并展示已读取数据的形状和标签。" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Image shape: (32, 32, 3) , Label: 4\n", "Image shape: (32, 32, 3) , Label: 1\n", "Image shape: (32, 32, 3) , Label: 6\n", "Image shape: (32, 32, 3) , Label: 9\n", "Image shape: (32, 32, 3) , Label: 9\n", "Image shape: (32, 32, 3) , Label: 1\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from mindspore.dataset import SubsetRandomSampler\n", "\n", "# 指定样本索引序列\n", "indices = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]\n", "sampler = SubsetRandomSampler(indices, num_samples=6)\n", "# 加载数据\n", "dataset = Cifar10Dataset(DATA_DIR, sampler=sampler)\n", "\n", "plt_result(dataset, 2)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印结果可以看到,采样器从索引序列中随机采样了6个样本。\n", "\n", "### PKSampler\n", "\n", "在指定的数据集类别P中,每种类别各采样K条数据。\n", "\n", "下面的样例使用PK采样器从CIFAR-10数据集中每种类别抽样2个样本,最多10个样本,并展示已读取数据的形状和标签。" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Image shape: (32, 32, 3) , Label: 0\n", "Image shape: (32, 32, 3) , Label: 0\n", "Image shape: (32, 32, 3) , Label: 1\n", "Image shape: (32, 32, 3) , Label: 1\n", "Image shape: (32, 32, 3) , Label: 2\n", "Image shape: (32, 32, 3) , Label: 2\n", "Image shape: (32, 32, 3) , Label: 3\n", "Image shape: (32, 32, 3) , Label: 3\n", "Image shape: (32, 32, 3) , Label: 4\n", "Image shape: (32, 32, 3) , Label: 4\n" ] }, { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from mindspore.dataset import PKSampler\n", "\n", "# 每种类别抽样2个样本,最多10个样本\n", "sampler = PKSampler(num_val=2, class_column='label', num_samples=10)\n", "dataset = Cifar10Dataset(DATA_DIR, sampler=sampler)\n", "\n", "plt_result(dataset, 3)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印结果可以看出,采样器对数据集中的每种标签都采样了2个样本,一共10个样本。\n", "\n", "### DistributedSampler\n", "\n", "在分布式训练中,对数据集分片进行采样。\n", "\n", "下面的样例展示了一个有12个样本的数据集,并使用分布式采样器将数据集划分为4个分片,每个分片的采样规则如下:\n", "\n", "| shard id | sample id |\n", "| -------- | ----------- |\n", "| shard 0 | 0, 4, 8 |\n", "| shard 1 | 1, 5, 9 |\n", "| shard 2 | 2, 6, 10 |\n", "| shard 3 | 3, 7, 11 |\n", "\n", "每个分片都包含3个样本,下面展示读取分片0中的包含的采样数据。" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "{'data': Tensor(shape=[], dtype=Int64, value= 0)}\n", "{'data': Tensor(shape=[], dtype=Int64, value= 4)}\n", "{'data': Tensor(shape=[], dtype=Int64, value= 8)}\n" ] } ], "source": [ "from mindspore.dataset import DistributedSampler\n", "\n", "# 自定义数据集\n", "data_source = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]\n", "\n", "# 构建的数据集分为4片,共采样3个数据样本\n", "sampler = DistributedSampler(num_shards=4, shard_id=0, shuffle=False)\n", "dataset = NumpySlicesDataset(data_source, column_names=[\"data\"], sampler=sampler)\n", "\n", "# 打印数据集\n", "for data in dataset.create_dict_iterator():\n", " print(data)" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印结果可以看出,数据集被分成了4片,每片有3个样本,本次获取的是id为0的片中的样本。\n", "\n", "## 自定义采样器\n", "\n", "用户可以自定义采样器,并将其应用到数据集上。\n", "\n", "### \\_\\_iter\\_\\_ 模式\n", "\n", "用户可以继承`Sampler`基类,通过实现`__iter__`方法来自定义采样器的采样方式。\n", "\n", "下面的样例定义了一个从下标0至下标9间隔为2采样的采样器,将其作用于自定义数据集,并展示已读取数据。" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a c e g i " ] } ], "source": [ "import mindspore.dataset as ds\n", "\n", "# 自定义采样器\n", "class MySampler(ds.Sampler):\n", " def __iter__(self):\n", " for i in range(0, 10, 2):\n", " yield i\n", "\n", "# 自定义数据集\n", "np_data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']\n", "\n", "# 加载数据\n", "dataset = ds.NumpySlicesDataset(np_data, column_names=[\"data\"], sampler=MySampler())\n", "for data in dataset.create_tuple_iterator(output_numpy=True):\n", " print(data[0], end=' ')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印可以看出,自定义的采样器读取了下标为0、2、4、6、8的样本数据,这与自定义采样器的采样目的一致。\n", "\n", "### \\_\\_getitem\\_\\_ 模式\n", "\n", "用户可以定义一个采样器类,该类包含 `__init__` 、 `__getitem__` 和 `__len__` 方法。\n", "\n", "下面的样例定义了一个下标为 `[3, 4, 3, 2, 0, 11, 5, 5, 5, 9, 1, 11, 11, 11, 11, 8]` 的采样器类,将其作用于自定义数据集,并展示已读取数据。" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "d e d c a l f f f j b l l l l i " ] } ], "source": [ "import mindspore.dataset as ds\n", "\n", "# 自定义采样器\n", "class MySampler():\n", " def __init__(self):\n", " self.index_ids = [3, 4, 3, 2, 0, 11, 5, 5, 5, 9, 1, 11, 11, 11, 11, 8]\n", " def __getitem__(self, index):\n", " return self.index_ids[index]\n", " def __len__(self):\n", " return len(self.index_ids)\n", "\n", "# 自定义数据集\n", "np_data = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l']\n", "\n", "# 加载数据\n", "dataset = ds.NumpySlicesDataset(np_data, column_names=[\"data\"], sampler=MySampler())\n", "for data in dataset.create_tuple_iterator(output_numpy=True):\n", " print(data[0], end=' ')" ] }, { "attachments": {}, "cell_type": "markdown", "metadata": {}, "source": [ "从上面的打印可以看出,自定义的采样器读取了下标为 `[3, 4, 3, 2, 0, 11, 5, 5, 5, 9, 1, 11, 11, 11, 11, 8]` 的样本数据,这与自定义采样器的采样目的一致。" ] } ], "metadata": { "kernelspec": { "display_name": "ly310", "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" } }, "nbformat": 4, "nbformat_minor": 4 }