命令行参数，设置随机数种子，生成小批量数据，数据打乱

0.命令行参数

if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    # data arguments
    parser.add_argument('--train_root', type=str, default='datasets/ml1m/test/train.txt')
    parser.add_argument('--test_root', type=str, default='datasets/ml1m/test/test.txt')
    parser.add_argument('--L', type=int, default=5, help='length of sequence')
    parser.add_argument('--T', type=int, default=3, help='number of targets')
    # train arguments
    parser.add_argument('--n_iter', type=int, default=50)
    parser.add_argument('--seed', type=int, default=1234)
    parser.add_argument('--batch_size', type=int, default=512)
    parser.add_argument('--learning_rate', type=float, default=1e-3)
    parser.add_argument('--l2', type=float, default=1e-6)
    parser.add_argument('--neg_samples', type=int, default=3)
    parser.add_argument('--use_cuda', type=str2bool, default=True)

    config = parser.parse_args()

1.设置随机数种子

def set_seed(seed, cuda=False):
    '''
    设置随机数种子的函数。通过调用该函数，可以设置numpy、random和torch的随机数种子，以实现结果的可重复性。
    Parameters
    ----------
    seed 设置的随机数种子的值
    cuda 表示是否使用CUDA加速

    Returns
    -------
    '''
    # 分别设置了numpy和Python内置的random模块的随机数种子
    np.random.seed(seed)
    random.seed(seed)
    # 设置PyTorch库的非CUDA和CUDA的随机数种子
    # 如果为True，则会调用torch.cuda.manual_seed(seed)设置CUDA相关的随机数种子；
    # 如果为False，则调用torch.manual_seed(seed)设置非CUDA相关的随机数种子。
    if cuda:
        torch.cuda.manual_seed(seed)
    else:
        torch.manual_seed(seed)

2.生成小批量数据

def minibatch(*tensors, **kwargs):
    '''
    这是一个用于生成小批量数据的函数。该函数接受可变数量的张量作为参数，并可以通过关键字参数 batch_size 指定批量大小（默认为128）。
    '''
    batch_size = kwargs.get('batch_size', 128)
    # 如果只有一个张量作为输入，则函数将对该张量进行分批操作。
    if len(tensors) == 1:
        tensor = tensors[0]
        # 使用一个 for 循环，每次迭代从起始索引 i 开始取出一个大小为 batch_size 的数据子集，并使用 yield 语句生成一个批次的数据。通过不断迭代，函数会生成所有的批次。
        for i in range(0, len(tensor), batch_size):
            yield tensor[i:i + batch_size]
    else:
        # 如果有多个张量作为输入，则函数将对这些张量进行分批操作。同样使用一个 for 循环，每次迭代从起始索引 i 开始，
        # 同时对每个张量进行切片并生成一个包含多个张量的批次。也是通过 yield 语句来生成批次数据。
        for i in range(0, len(tensors[0]), batch_size):
            yield tuple(x[i:i + batch_size] for x in tensors)

3.数据随机打乱

def shuffle(*arrays, **kwargs):
    '''
    这个函数可以用于对多个数组进行一致的随机打乱，适用于需要将多个数组的元素顺序打乱到相同顺序的情况。
    Parameters
    ----------
    arrays
    kwargs

    Returns
    -------
    '''
    # 获取关键字参数字典 kwargs 中键为 'indices' 的值。如果 'indices' 存在，则返回对应的值；如果 'indices' 不存在，则返回默认值 False。
    require_indices = kwargs.get('indices', False)
    # 首先，函数会检查输入的各个数组是否具有相同的长度，如果长度不一致，则会抛出 ValueError 异常。
    if len(set(len(x) for x in arrays)) != 1:
        raise ValueError('All inputs to shuffle must have '
                         'the same length.')

    # 函数会生成一个索引数组 shuffle_indices，其长度与第一个输入数组相同，并对该数组进行随机打乱
    shuffle_indices = np.arange(len(arrays[0]))
    np.random.shuffle(shuffle_indices)

    # 根据输入的数组个数决定如何处理打乱后的索引。如果只有一个输入数组，那么直接使用 shuffle_indices 对该数组进行索引操作，得到结果数组 result。
    if len(arrays) == 1:
        result = arrays[0][shuffle_indices]
    else:
        # 如果有多个输入数组，那么对每个数组都按照 shuffle_indices 进行索引操作，并将结果保存在一个元组中
        result = tuple(x[shuffle_indices] for x in arrays)

    # 如果 require_indices 参数为 True，则同时返回打乱后的结果数组和打乱后的索引数组；否则，只返回打乱后的结果数组
    if require_indices:
        return result, shuffle_indices
    else:
        return result