循环神经网络-数据集

import random

import torch

def seq_data_iter_random(corpus,batch_size,num_steps):

    """

    使用随机变量抽样生成一个小批量子序列

    :param corpus: 语料库，通常是一个包含 token ID 的长列表或序列。

    :param batch_size: 每个小批量中包含的子序列数量。

    :param num_steps: 每个子序列的长度（时间步数）。

    :return: 一个生成器，每次产出 (X, Y) 张量对。

    """

    # 首先生成一个 0 到 num_steps - 1 之间的随机整数，然后将 corpus 从这个随机索引位置开始进行切片。这个随机索引之前的所有数据都被丢弃了。

    corpus = corpus[random.randint(0,num_steps-1):]

    # 计算可以获得多少个长度为 num_steps 的子序列

    num_subseqs = (len(corpus) - 1) // num_steps

    """

    创建一个包含所有子序列起始索引的列表。这些索引从 0 开始，每次增加 num_steps。这定义了语料库中 不重叠 的块的起始点。例如，如果 num_subseqs = 5 且 num_steps = 10，则 initial_indices 会是 [0, 10, 20, 30, 40]。

    """

    initial_indices = list(range(0,num_subseqs * num_steps,num_steps))

    # 将这些起始索引进行随机排序。这是该函数实现 “随机抽样” 的核心：不是按顺序处理子序列，而是随机选择它们的起始位置。

    random.shuffle(initial_indices)

    def data(pos):

        # 返回从 pos 位置开始，长度为 num_steps 的子序列

        return corpus[pos: pos + num_steps]

    # 返回的批次数量

    num_batches = num_subseqs // batch_size

    for i in range(0, batch_size  * num_batches, batch_size):

        # 在这里，initial_indices 的长度可能不足 batch_size (如果 num_subseqs 不能被 batch_size 整除) 但循环范围保证了我们只取完整的批次

        initial_indices_per_batch = initial_indices[i: i + batch_size]

        X = [data(j) for j in initial_indices_per_batch]

        # 注意：Y 应该是 X 向后移动一位的结果

        Y = [data(j + 1) for j in initial_indices_per_batch]

        yield torch.tensor(X), torch.tensor(Y)

my_seq = list(range(35))

for X, Y in seq_data_iter_random(my_seq, batch_size=2, num_steps=5):

    print('X:', X, 'Y:', Y)

def seq_data_iter_seqiuential(corpus,batch_size,num_steps):

    """

    使用顺序分区生成小批量子序列

     从一个长序列 corpus 中，生成一系列小批量 (X, Y) 数据对，其中 X 是输入子序列，Y 是对应的目标子序列（通常是 X 向后移动一个时间步）。这种方法试图保持数据的部分顺序性，同时将数据分割成适合并行处理的批次。

    :param corpus: 语料库 (列表或类似序列的对象，包含 token ID)

    :param batch_size: 批量大小 (每个批次包含多少条序列)

    :param num_steps: 每个子序列的时间步长

    :return:

    """

    offset = random.randint(0,num_steps)

    """

    计算从偏移量 offset 之后可用的 token 数量。减 1 是因为我们需要为 Y 序列留出最后一个 token 的对应目标（即 Y 比 X 晚一个位置）。

    将可用 token 数整除以 batch_size。这计算出，如果我们将这些 token 平均分配到 batch_size 个并行的序列中，每条序列 可以包含多少个 token。

    将上面得到的“每条序列的 token 数”再乘以 batch_size。这得到了最终要使用的 总 token 数量 (num_tokens)。这样做可以确保这个总数 num_tokens 能够被 batch_size 整除，方便后续的 reshape 操作。

    """

    num_tokens = ((len(corpus) - offset - 1) // batch_size) * batch_size

    """

    从语料库中提取从 offset 开始，总共 num_tokens 个 token，并将它们转换成一个 PyTorch 张量。此时 Xs 是一个一维张量（形状为 [num_tokens]）。

    """

    Xs = torch.tensor([corpus[offset: offset + num_tokens]])

    Ys = torch.tensor([corpus[offset + 1: offset + 1 + num_tokens]])

    """

    核心：

    Xs.reshape(batch_size, -1): 将一维的长张量 Xs (包含 num_tokens 个元素) 重塑成一个二维张量，形状为 (batch_size, num_tokens // batch_size)。

    这个 reshape 操作会按顺序将 Xs 中的数据填充到新的二维张量中。结果是，第一行 (Xs[0, :]) 包含了原始序列的第一个块，第二行 (Xs[1, :]) 包含了原始序列的第二个块，以此类推，直到第 batch_size 行。这意味着来自同一个时间步但在不同批次样本（不同行）的数据，在原始语料库中并不相邻。相反，同一行内的数据在原始语料库中是连续的。这与许多期望数据按 (时间步, 批次) 排列的模型输入方式不同。

    """

    Xs , Ys = Xs.reshape(batch_size,-1), Ys.reshape(batch_size,-1)

    """

    Xs.shape[1] 获取 reshape 后 Xs 张量的列数，也就是每条并行序列的长度 (num_tokens // batch_size)。

用这个长度整除以 num_steps（每个子序列的长度），得到可以从每条并行序列中切分出多少个长度为 num_steps 的完整子序列。这就是我们能生成的批次总数 num_batches。

    """

    num_batches = Xs.shape[1] // num_steps

    """

    这个循环沿着 reshape 后的张量的列（时间步维度）进行迭代，步长为 num_steps。i 代表当前批次子序列的起始列索引。

    X = Xs[:, i : i + num_steps]: 从 Xs 中提取当前批次的输入数据。它选择所有行 (:)，即 batch_size 个并行序列，并从列 i 到 i + num_steps（不包含）提取数据。结果 X 是一个形状为 (batch_size, num_steps) 的张量。

    Y = Ys[:, i : i + num_steps]: 同样地从 Ys 中提取对应的目标批次。由于 Ys 在创建时就已经相对于 Xs 移动了一位，所以这里得到的 Y 正好是 X 的下一个时间步的目标。Y 的形状也是 (batch_size, num_steps)。

    yield X, Y: 生成器返回当前的 (X, Y) 张量对。

"""

    for i in range(0,num_steps * num_batches,num_steps):

        X = Xs[:,i: i + num_steps]

        Y = Ys[:,i: i + num_steps]

        yield X, Y

for X,Y in seq_data_iter_seqiuential(my_seq, batch_size=2, num_steps=5):

    print('X:', X, '\nY:', Y)

import rnn.text_preprocessing as pp

class SeqDataLoader:

    def __init__(self,batch_size,num_steps,use_random_iter, max_tokens):

        if use_random_iter:

            self.data_iter_fn = seq_data_iter_random

        else:

            self.data_iter_fn = seq_data_iter_seqiuential

            """调用文本预处理的函数"""

        self.corpus , self.vocab = pp.load_corpus_time_machine(max_tokens)

        self.batch_size, self.num_steps = batch_size, num_steps

    def __iter__(self):

        return self.data_iter_fn(self.corpus, self.batch_size, self.num_steps)

def load_data_time_machine(batch_size, num_steps, use_random_iter=False,max_tokens=10000):

    data_iter = SeqDataLoader(

        batch_size,

        num_steps,

        use_random_iter=use_random_iter,

        max_tokens=max_tokens

    )

    return data_iter, data_iter.vocab