Pytorch：嵌入层Embedding、EmbeddingBag

谁践踏了优雅 2023-07-26 05:40 189阅读 0赞

# ![20191009191333910.png][][日萌社][Link 1] #

[人工智能AI：Keras PyTorch MXNet TensorFlow PaddlePaddle 深度学习实战（不定时更新）][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]

--------------------

Embedding
            keras.layers.Embedding(input_dim, output_dim, embeddings_initializer='uniform', 
                                    embeddings_regularizer=None, activity_regularizer=None, 
                                    embeddings_constraint=None, mask_zero=False, input_length=None)
                1.将正整数（索引值）转换为固定尺寸的稠密向量。 例如： [[4], [20]] -> [[0.25, 0.1], [0.6, -0.2]]
                  该层只能用作模型中的第一层。
                2.Embedding层输入是一维[单个字符/单个单词]，那么输出为二维[单个字符/单个单词, embedding_dim]；
                  Embedding层输入是二维[batch_size, 单个字符/单个单词]，那么输出为三维[batch_size, 单个字符/单个单词, embedding_dim]。
                
            1.例子
                model = Sequential()
                model.add(Embedding(1000, 64, input_length=10))
                # 模型将输入一个大小为 (batch, input_length) 的整数矩阵。
                # 输入中最大的整数（即词索引）不应该大于 999 （词汇表大小）
                # 现在 model.output_shape == (None, 10, 64)，其中 None 是 batch 的维度。
                # 输入input_array的shape为(batch_size, sequence_length) 的 2D 张量
                input_array = np.random.randint(1000, size=(32, 10))
                model.compile('rmsprop', 'mse')
                #输出output_array的shape为(batch_size, sequence_length, output_dim) 的 3D 张量
                output_array = model.predict(input_array)
                assert output_array.shape == (32, 10, 64)
            2.输入尺寸
                尺寸为 (batch_size, sequence_length) 的 2D 张量。
            3.输出尺寸
                尺寸为 (batch_size, sequence_length, output_dim) 的 3D 张量。
            4.参数
                input_dim: int > 0。词汇表大小， 即，最大整数 index + 1。
                output_dim: int >= 0。词向量的维度。
                embeddings_initializer: embeddings 矩阵的初始化方法 (详见 initializers)。
                embeddings_regularizer: embeddings matrix 的正则化方法 (详见 regularizer)。
                embeddings_constraint: embeddings matrix 的约束函数 (详见 constraints)。
                mask_zero: 
                    是否把 0 看作为一个应该被遮蔽的特殊的 "padding" 值。这对于可变长的 循环神经网络层 十分有用。 
                    如果设定为 True，那么接下来的所有层都必须支持 masking，否则就会抛出异常。 
                    如果 mask_zero 为 True，作为结果，索引 0 就不能被用于词汇表中（input_dim 应该与 vocabulary + 1 大小相同）。
                input_length: 
                        输入序列的长度，当它是固定的时。 如果你需要连接 Flatten 和 Dense 层，
                        则这个参数是必须的 （没有它，dense 层的输出尺寸就无法计算）。

import torch.nn as nn
    import torch
    
    embedding = nn.Embedding(10, 3)
    x = torch.tensor([[0,1],[8,9]])
    result = embedding(x)
    # print(result)
    # tensor([[[ 0.8168, -0.9338, -0.3293],
    #          [ 0.8791,  0.4560,  1.4109]],
    #         [[ 0.3612,  0.9988, -0.5982],
    #          [ 0.8584, -0.5055,  1.5467]]], grad_fn=<EmbeddingBackward>)
    
    """
    设置padding_idx=0之后，那么传入的索引值0通过Embedding层之后，索引值0对应的输出权重值全为0.0000
    """
    embedding = nn.Embedding(10, 3, padding_idx=0)
    x = torch.tensor([[0,1],[8,9]])
    result = embedding(x)
    print(result)
    # tensor([[[ 0.0000,  0.0000,  0.0000],
    #          [-1.3279,  0.6434, -0.5540]],
    #         [[-0.2641,  0.1417,  0.0175],
    #          [-2.8311,  2.0384, -0.0970]]], grad_fn=<EmbeddingBackward>)
    
    """
    报错：RuntimeError: index out of range: Tried to access index 10 out of table with 9 rows.
    报错意思可以翻译为：RuntimeError: index out of range: Tried to access index vocab词表大小 out of table with 单词索引值 rows.
    分析：Embedding(词表大小, 词嵌入维度)：
            1.词表大小代表所有不重复单词数的总数大小，词嵌入维度代表一个单词对应的词嵌入维度的向量。
              Embedding底层中会构建一个“词表大小*词嵌入维度”的二维权重矩阵，行数即为词表大小，列数即为词嵌入维度。
              每个不重复的词的索引值对应二维权重矩阵中的一行，那么一个单词通过Embedding层输出后为该单词的索引对应那行的词嵌入维度向量，
              也就是说把该单词的索引值对应的二维权重矩阵中的那一行的词嵌入维度向量取出来，作为该单词对应的权重值向量信息。
            2.<start>和<end>同样一开始也是要放到词表WordToIndex和IndexToWord的两个字典中，<start>对应索引值0，<end>对应索引值1。
            3.Embedding层要求传入的单词索引值必须在“0到词表大小减1”的这个范围之间，传入到Embedding层中的单词索引值大于或等于词表大小值的时候，
              就会报错表示单词索引值超出了词表大小范围。
    """
    embedding = nn.Embedding(10, 3)
    x = torch.tensor([[0,1],[5,10]])
    result = embedding(x)
    print(result)

--------------------

# **[Embedding版本.py][AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]** #

""" pip install torchtext """
    # 导入torchtext.datasets中的文本分类任务
    # from torchtext.datasets import text_classification
    
    from day04 import My_text_classification
    
    # 导入相关的torch工具包
    import torch
    import os
    # 导入必备的torch模型构建工具
    import torch.nn as nn
    import torch.nn.functional as F
    # 导入torch中的数据加载器方法
    from torch.utils.data import DataLoader
    # 导入时间工具包
    import time
    # 导入数据随机划分方法工具
    from torch.utils.data.dataset import random_split
    import numpy as np
    #================================================================================================
    
    # 指定BATCH_SIZE的大小
    BATCH_SIZE = 2
    
    # 进行可用设备检测, 有GPU的话将优先使用GPU
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    # 定义数据下载路径, 当前路径的data文件夹
    load_data_path = "./data"
    # 如果不存在该路径, 则创建这个路径
    if not os.path.isdir(load_data_path):
        os.mkdir(load_data_path)
    
    """
    注意：
        因为调用text_classification这个API的话，每次调用都会自动下载，因此修改text_classification其中的源码。
        首先拷贝一份text_classification.py修改为My_text_classification放到自己项目中，
        把所调用的底层中函数中的第一行download_from_url(URLS[dataset_name], root=root) 注释掉
    """
    # 选取torchtext中的文本分类数据集'AG_NEWS'即新闻主题分类数据, 保存在指定目录下
    # 并将数值映射后的训练和验证数据加载到内存中
    train_dataset, test_dataset = My_text_classification.DATASETS['AG_NEWS'](root=load_data_path)
    # train_dataset, test_dataset = text_classification.DATASETS['AG_NEWS'](root=load_data_path)
    
    """
    1.EmbeddingBag API官方介绍：
        https://pytorch.org/docs/stable/nn.html?highlight=embeddingbag#torch.nn.EmbeddingBag
    2.torch.nn.EmbeddingBag(num_embeddings, embedding_dim, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, 
                            mode='mean', sparse=False, _weight=None)
        参数解释：
            计算嵌入的“bags”的sums或means的方法，而不实例化中间嵌入embeddings。
            对于长度恒定且无per_sample_weights的bags，该类
            其中 mode="sum" 等于嵌入 Embedding 后跟 torch.sum(dim=0)
            其中 mode="mean" 等于嵌入 Embedding 后跟 torch.mean(dim=0)
            其中 mode="max" 等于嵌入 Embedding 后跟 torch.max(dim=0)
        使用：
            embedding = nn.EmbeddingBag(vocab_size, embed_dim)  
            embedding(input, offsets)
        参数解释：    
            vocab_size: 词汇表不重复单词总数，整个语料包含的不同词汇的总数
            embed_dim: 指定词嵌入的维度，一个单词的词嵌入维度
            input：批量样本数据，用于准备输入到Embedding层中进行嵌入张量化
            offsets：
                offsets为一维张量，张量中每个值为每个句子头个单词在当前批量样本句子数据中的起始位置。
                可以通过间接的方式计算出每个句子头个单词在当前批量样本句子数据中的起始位置，
                首先计算出每个句子的长度，即每个句子中的单词数，然后通过cumsum函数可以计算出每个元素值的累计和，
                比如[1.0, 2.0, 3.0] 通过cumsum函数计算出结果为[1., 3., 6.]，即每个元素值是第一个元素值到当前元素值的累计和，
                那么便可以通过这种方式，传入每个句子的长度到cumsum函数计算出每个句子的累计和，
                那么即得出每个句子在当前批量样本句子数据中的起始位置。
    3.例子
        >>> # vocab_size=10, embed_dim=3
        >>> embedding_sum = nn.EmbeddingBag(10, 3, mode='sum')
        >>> # 一个批量有2个样本，每个样本有4个数值
        >>> input = torch.LongTensor([1,2,4,5, 4,3,2,9])
        >>> #每个句子的头个单词的索引位置，即每个句子头个单词的起始位置
        >>> #offsets必须是1D张量，1D张量中每个值为input中每个bag(样本句子)的起始索引位置
        >>> #因为知道每个样本有4个数值，因此0为第一个句子头个单词的起始位置，4为第二个句子头个单词的起始位置
        >>> offsets = torch.LongTensor([0, 4])
        >>> embedding_sum(input, offsets)
        tensor([[-0.8861, -5.4350, -0.0523],
                [ 1.1306, -2.5798, -1.0044]])
    """
    
    """
    第一步: 构建带有Embedding层的文本分类模型
    """
    class TextSentiment(nn.Module):
        """文本分类模型"""
        def __init__(self, vocab_size, embed_dim, num_class):
            """
            description: 类的初始化函数
            :param vocab_size: 整个语料包含的不同词汇总数
            :param embed_dim: 指定词嵌入的维度
            :param num_class: 文本分类的类别总数
            """
            super().__init__()
            """
            使用torch.optim.Adam(model.parameters(), lr=0.1)后报错如下：
                RuntimeError: Adam does not support sparse gradients, please consider SparseAdam instead
            分析：因为Adam的关系，所以nn.Embedding(vocab_size, embed_dim, sparse=True)中的sparse不能等于True，必须为False
            解决：nn.Embedding(vocab_size, embed_dim, sparse=False)
            """
            # 实例化embedding层, sparse=True代表每次对该层求解梯度时, 只更新部分权重。使用Adam时，需要把设置sparse不能设置为True
            #nn.Embedding(vocab_size 词汇总数, embed_dim 单词嵌入维度)
            self.embedding = nn.Embedding(vocab_size, embed_dim, sparse=False) #vocab_size 95812，embed_dim 32
             # 实例化线性层, 参数分别是embed_dim和num_class
            self.fc = nn.Linear(embed_dim, num_class) #embed_dim 32，num_class 4
            # 为各层初始化权重
            self.init_weights()
    
        def init_weights(self):
            """初始化权重函数"""
            # 指定初始权重的取值范围数
            initrange = 0.5
            # 各层的权重参数都是初始化为均匀分布
            self.embedding.weight.data.uniform_(-initrange, initrange) #初始化 -0.5 到 0.5之间
            self.fc.weight.data.uniform_(-initrange, initrange) #初始化 -0.5 到 0.5之间
            # 偏置初始化为0
            self.fc.bias.data.zero_() ##初始化 0
    
        """
        output = model(text)
            每次训练传入的text为tensor类型的一维数组，数组中的值均为单词对应在词汇列表中的索引值。
            text由16个句子的批量大小组成的一维数组，因此每个句子的长度都不一致的关系，
            因此每个一维数组text的长度都不一致。
            
        embedded = self.embedding(text)
            embedded.shape为(m, 32)，m为批量大小16个句子的单词总数，并且每个批量的embedded(同text原理)的m都是不相同的，
            32为单词的嵌入维度(权重维度)。
        
        c = embedded.size(0) // BATCH_SIZE
        embedded = embedded[:BATCH_SIZE*c] 
            已知m的值远大于BATCH_SIZE=16，为了在模型中以便通过fc层后能计算相应的损失，
            实际即为了(m, 32)中的m维度值可以整除BATCH_SIZE，
            因此还需要将(m, 32) 转化成 (m//BATCH_SIZE*BATCH_SIZE, 32)，c为批量个数，
            即先用m整除BATCH_SIZE, 获得m中共包含c个BATCH_SIZE，之后再从embedded中取c*BATCH_SIZE个向量得到新的embedded。
            这个新的embedded中的向量个数可以整除BATCH_SIZE。
     
        embedded = embedded.transpose(1, 0).unsqueeze(0)
        embedded = F.avg_pool1d(embedded, kernel_size=c)
             因为我们想利用平均池化的方法求embedded中指定行数的列的平均数，但平均池化方法是作用在行上的, 
             并且需要3维输入因此我们对新的embedded进行转置后并拓展维度。
             首先transpose(1, 0)把embedded的(m, 32)转换为(32, m)，然后unsqueeze(0)拓展维度变成(1, 32, m)，
             然后就是调用平均池化avg_pool1d方法, 并且核的大小kernel_size为c(批量个数)，
             即取每c个的元素计算一次均值作为结果，即最终有 m/c(批量个数)个平均值，
             即是对(m, 32)的embedded 中的m 即按行进行求平均值，
             实际即 一共有m个单词，每个单词的嵌入维度为32，那么如果对每个单词的嵌入维度求平均值是毫无意义的，
             应该是求一段单词的平均值，因此kernel_size=c 实际即卷积核的大小为c，那么就是按照c个单词数求一个平均值。
            
        embedded.shape: torch.Size([625, 32])
        c: 39 # 625 / batch_size(16) = 39.0625
        embedded.shape: torch.Size([624, 32]) # 39 * batch_size(16) = 624
        embedded.shape: torch.Size([1, 32, 624]) 
        embedded.shape: torch.Size([1, 32, 16]) # 624 / 39 = 16
        """
        def forward(self, text):
            """
            :param text: 文本数值映射后的结果
            :return: 与类别数尺寸相同的张量, 用以判断文本类别
            """
            # 获得embedding的结果embedded
            # >>> embedded.shape
            # (m, 32) 其中m是BATCH_SIZE大小的数据中词汇总数
            embedded = self.embedding(text)
            # print("embedded.shape:",embedded.shape)
    
            # 接下来我们需要将(m, 32)转化成(BATCH_SIZE, 32)
            # 以便通过fc层后能计算相应的损失
            # 首先, 我们已知m的值远大于BATCH_SIZE=16,
            # 用m整除BATCH_SIZE, 获得m中共包含c个BATCH_SIZE
            c = embedded.size(0) // BATCH_SIZE
            # print("c:",c)
    
            # 之后再从embedded中取c*BATCH_SIZE个向量得到新的embedded
            # 这个新的embedded中的向量个数可以整除BATCH_SIZE
            embedded = embedded[:BATCH_SIZE*c]
            # print("embedded.shape:",embedded.shape)
    
            # 因为我们想利用平均池化的方法求embedded中指定行数的列的平均数,
            # 但平均池化方法是作用在行上的, 并且需要3维输入
            # 因此我们对新的embedded进行转置并拓展维度
            embedded = embedded.transpose(1, 0).unsqueeze(0)
            # print("embedded.shape:",embedded.shape)
    
            # 然后就是调用平均池化的方法, 并且核的大小为c
            # 即取每c的元素计算一次均值作为结果
            embedded = F.avg_pool1d(embedded, kernel_size=c)
            # print("embedded.shape:",embedded.shape)
    
            # embedded = F.relu(embedded)
    
            # 最后，还需要减去新增的维度, 然后转置回去输送给fc层
            return self.fc(embedded[0].transpose(1, 0))
    
    """
    实例化模型
    """
    # 获得整个语料包含的不同词汇总数
    VOCAB_SIZE = len(train_dataset.get_vocab())
    # 指定词嵌入维度
    EMBED_DIM = 32
    # 获得类别总数
    NUN_CLASS = len(train_dataset.get_labels())
    # print("VOCAB_SIZE词数:",VOCAB_SIZE) # 95812
    # print("NUN_CLASS类别数:",NUN_CLASS) # 4
    
    # 实例化模型
    model = TextSentiment(VOCAB_SIZE, EMBED_DIM, NUN_CLASS).to(device)
    
    """
    第二步: 对数据进行batch处理
    """
    def generate_batch(batch):
        """
        description: 生成batch数据函数
        :param batch: 由样本张量和对应标签的元组组成的batch_size大小的列表
                      形如:  [(label1, sample1), (label2, sample2), ..., (labelN, sampleN)]
        :return: 样本张量和标签各自的列表形式(张量)
                 形如:
                 text = tensor([sample1, sample2, ..., sampleN])
                 label = tensor([label1, label2, ..., labelN])
        """
        """
        batch：16个数据，格式为(标签值,样本数据)，一共有16个这样的元祖构成一个列表
        """
        # print("batch size批量样本数:",len(batch)) # 列表中有 16 个元祖
        # print("batch[0][0]:",batch[0][0]) # 元祖中的 int标签值
        # print("batch[0][1]:",batch[0][1]) # 元祖中的 样本数据，数据值为单词在词汇列表中的索引值
    
        # 从batch中获得样本张量
        # text = torch.tensor()
        text = [entry[1] for entry in batch]
        # 从batch中获得标签张量
        label = [entry[0] for entry in batch]
        # print("batch_size批量大小的样本特征:", len(text)) #16
        # print("batch_size批量大小的标签:", len(label)) #16
    
        # text中包含16个句子，每个句子的长度都不一样，最终通过cat函数把16个句子的单词都封装到一个列表中
        #text中的值 实际是16句子中的单词对应的索引值，因此cat函数封装成的一个列表中的元素值都是单词对应的索引值
        #每个批量的16个句子都是长度不一致，因此每个批量中的text.shape都可能是不相同
        text = torch.cat(text)
        label = torch.tensor(label) #使用 torch.tensor 把 list 转换为 tensor类型
        # print("cat(text):", text.shape)  #每个批量中的text的长度(16个句子一共的单词数)都可能是不相同
        # print("label:", label.shape)  #torch.Size([16]) 16个句子对应的标签值
    
        # 返回结果
        return text.to(device), label.to(device)
    
    """
    第三步: 构建训练与验证函数
    """
    
    # 指定训练轮数
    N_EPOCHS = 100
    # 定义初始的验证损失
    # min_valid_loss = float('inf')
    # 选择损失函数, 这里选择预定义的交叉熵损失函数
    criterion = torch.nn.CrossEntropyLoss().to(device)
    # 选择随机梯度下降优化器
    # optimizer = torch.optim.SGD(model.parameters(), lr=0.1)
    optimizer = torch.optim.Adam(model.parameters(),lr=0.01,betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
    # 选择优化器步长调节方法StepLR, 用来衰减学习率
    # 5个step调节一次例如，每执行一次scheduler.step()为一个step。
    # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)
    # scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=N_EPOCHS)
    
    """
        使用torch.optim.Adam(model.parameters(), lr=0.1)后报错如下：
            RuntimeError: Adam does not support sparse gradients, please consider SparseAdam instead
        分析：因为Adam的关系，所以nn.Embedding(vocab_size, embed_dim, sparse=True)中的sparse不能等于True，必须为False
        解决：nn.Embedding(vocab_size, embed_dim, sparse=False)
           
    class torch.optim.lr_scheduler.StepLR(optimizer,step_size,gamma=0.1,last_epoch=-1)
        optimizer(Optimizer对象)--优化器
        step_size(整数类型): 调整学习率的步长,每过step_size次,更新一次学习率。每执行一次scheduler.step()为一个step
        gamma(float 类型):学习率下降的乘数因子
        last_epoch(int类型):最后一次epoch的索引,默认为-1.
    """
    
    def train(train_data):
        """模型训练函数"""
        # 初始化训练损失和准确率为0
        train_loss = 0
        train_acc = 0
    
        # 使用数据加载器生成BATCH_SIZE大小的数据进行批次训练
        # data就是N多个generate_batch函数处理后的BATCH_SIZE大小的数据生成器
        #drop_last=True：丢弃不满足批量大小的批量数据，一般会是最后一个批量数据中的样本数可能不满足于批量大小，因此需要丢弃以防止报错
        data = DataLoader(train_data, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
    
        # 对data进行循环遍历, 使用每个batch的数据进行参数更新
        for i, (text, cls) in enumerate(data):
            """
            如果当前批量数据中的样本数不满足批量大小的话，执行后面就会报错，因此需要每次训练的批量数据中的样本数必须满足批量大小
            常见的情况就是一般最后一个批次数据中的样本数可能存在不满足于批量大小，因此都需要判断这个步骤
            """
            # if len(cls) != BATCH_SIZE:
            #     continue
            # 设置优化器初始梯度为0
            optimizer.zero_grad()
            # 模型输入一个批次数据, 获得输出
            output = model(text)
            """
            模型最后一个输出层输出的维度是类别数4，那么因为每个批量大小为16，
            那么一个批量中的真实标签值一共有16个int值(16个句子对应16个真实标签值)。
            因此模型的预测输出的维度是torch.Size([16, 4])，和真实标签值列表[16] 进行比较是否相同。
            """
            # print("output:",output.shape) #torch.Size([16, 4])
            # 根据真实标签与模型输出计算损失
            loss = criterion(output, cls)
            # 将该批次的损失加到总损失中
            train_loss += loss.item()
            # print("loss:",loss.item()) # loss.item()为一个 float小数值
    
            # 误差反向传播
            loss.backward()
            # 参数进行更新
            optimizer.step()
            """
            output维度为 [16, 4]。
            output.argmax(1) 取的是每行中最大元素值的索引值，一共有16行，那么最终得出16个索引值。
            output.argmax(0) 在此处使用的话为错误用法，只能取出4个值，取出的是 每列中最大元素值的索引值。 
            """
            # 将该批次的准确率加到总准确率中
            train_acc += (output.argmax(1) == cls).sum().item()
    
        # 调整优化器学习率
        # scheduler.step()
        """
        len(train_data) 获取的是训练样本数量 114000
        使用 train_loss/训练样本数量，train_acc/训练样本数量
        """
        # 返回本轮训练的平均损失和平均准确率
        return train_loss / len(train_data), train_acc / len(train_data)
    
    def valid(valid_data):
        """模型验证函数"""
        # 初始化验证损失和准确率为0
        loss = 0
        acc = 0
    
        # 和训练相同, 使用DataLoader获得训练数据生成器
        #drop_last=True：丢弃不满足批量大小的批量数据，一般会是最后一个批量数据中的样本数可能不满足于批量大小，因此需要丢弃以防止报错
        data = DataLoader(valid_data, batch_size=BATCH_SIZE, collate_fn=generate_batch, drop_last=True)
        # 按批次取出数据验证
        for text, cls in data:
            """
            如果当前批量数据中的样本数不满足批量大小的话，执行后面就会报错，因此需要每次训练的批量数据中的样本数必须满足批量大小
            常见的情况就是一般最后一个批次数据中的样本数可能存在不满足于批量大小，因此都需要判断这个步骤
            """
            # if len(cls) != BATCH_SIZE:
            #     continue
            # 验证阶段, 不再求解梯度
            with torch.no_grad():
                # 使用模型获得输出
                output = model(text)
                # 计算损失
                loss = criterion(output, cls)
                # 将损失和准确率加到总损失和准确率中
                loss += loss.item()
                acc += (output.argmax(1) == cls).sum().item()
    
        # 返回本轮验证的平均损失和平均准确率
        return loss / len(valid_data), acc / len(valid_data)
    
    
    """
    第四步: 进行模型训练和验证
    """
    def train_model():
        train_dataset_size = len(train_dataset)
        # print("train_dataset 总样本数",train_dataset_size) #120000
    
        # 从train_dataset取出0.95作为训练集, 先取其长度
        train_len = int(train_dataset_size * 0.95)
        valid_len = train_dataset_size - train_len
        # print("train_len 训练样本数",train_len) #114000
        # print("valid_len 验证本数",valid_len) #6000
    
        # while 1:
        #     if (train_len % BATCH_SIZE == 0):
        #         break
        #     else:
        #         train_len -= 1
        # while 1:
        #     if (valid_len % BATCH_SIZE == 0):
        #         break
        #     else:
        #         valid_len -= 1
        # print("处理后的训练样本数： %d, 处理后的验证样本数： %d" % (train_len, valid_len))
    
        # 然后使用random_split进行乱序划分, 得到对应的训练集和验证集
        sub_train_, sub_valid_ = random_split(train_dataset, [train_len, valid_len])
    
        """
        RuntimeError: Expected object of backend CUDA but got backend CPU for argument #3 'index'
        分析：data数据或者model没有调用.to(device)
        解决：
            # 进行可用设备检测, 有GPU的话将优先使用GPU
            device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
            model = model.to(device) 或 model = model.cuda(device)
            output = model(input.to(device)) 或 output = model(input.cuda(device))
            # 选择损失函数, 这里选择预定义的交叉熵损失函数
            criterion = torch.nn.CrossEntropyLoss().to(device) 或 criterion = torch.nn.CrossEntropyLoss().cuda(device)
            loss = criterion(output, lable.to(device)) 或 loss = criterion(output, lable.cuda(device))
        """
    
        # 开始每一轮训练
        for epoch in range(N_EPOCHS):
            # 记录概论训练的开始时间
            start_time = time.time()
            # 调用train和valid函数得到训练和验证的平均损失, 平均准确率
            train_loss, train_acc = train(sub_train_)
            valid_loss, valid_acc = valid(sub_valid_)
    
            # 计算训练和验证的总耗时(秒)
            secs = int(time.time() - start_time)
            # 用分钟和秒表示
            mins = secs / 60
            secs = secs % 60
    
            # 打印训练和验证耗时，平均损失，平均准确率
            print('Epoch: %d' % (epoch + 1), " | time in %d minutes, %d seconds" % (mins, secs))
            print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)')
            print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')
    
    if __name__ == '__main__':
        """
        Epoch: 98  | time in 1 minutes, 0 seconds
    	Loss: 0.0427(train)	|	Acc: 94.5%(train)
    	Loss: 0.0000(valid)	|	Acc: 87.0%(valid)
        """
        train_model()

--------------------

# **EmbeddingBag版本.py** #

from day04 import My_text_classification
    from torchtext.datasets.text_classification import *
    import os
    import torch.nn as nn
    import torch.nn.functional as F
    
    """
    BATCH_SIZE大小设置对训练耗时的影响：
        1.如果当设置BATCH_SIZE等于训练样本时，比如训练样本有512个，设置BATCH_SIZE=512，那么一次BATCH_SIZE=512的批量数据进行训练时，
          会计算BATCH_SIZE=512个样本的反向传播，求出512个样本的梯度累计和，然后使用该梯度累计和进行一次权重参数更新。
        2.如果当设置BATCH_SIZE等于1时，，比如训练样本有512个，设置BATCH_SIZE=1，那么一次BATCH_SIZE=1的批量数据进行训练时，
          会计算BATCH_SIZE=1个样本的反向传播，求出1个样本的梯度，然后使用该梯度进行一次权重参数更新，
          那么当所有512个样本都完成训练时，一共进行了512次反向传播(梯度计算)，512次参数更新。
        3.结论：
            1.显然BATCH_SIZE设置越大，那么所有训练样本数据完成一次训练(完成一个epoch)要进行的参数更新次数会更少，
              那么训练耗时更短，BATCH_SIZE设置越小，一个epoch训练完所有样本数据要进行的参数更新次数会更多，
              因此训练耗时更长。
            2.当然训练耗时也和你所选取的优化算法是全批量梯度下降BGD、随机梯度下降SGD、小批量梯度下降Mini-batch GD(MBGD)有关。
        4.每个批量数据训练都要执行的代码流程
            # 设置优化器初始梯度为0
            optimizer.zero_grad()
            # 模型输入一个批次数据, 获得输出
            output = model(text)
            # 根据真实标签与模型输出计算损失
            loss = criterion(output, label)
            # 将该批次的损失加到总损失中
            train_loss += loss.item()
            # 误差反向传播
            loss.backward()
            # 参数进行更新
            optimizer.step()
    """
    learning_rate = 0.01
    train_ratio = 0.95
    N_EPOCHS = 50
    BATCH_SIZE = 1000
    EMBED_DIM = 32
    
    # 进行可用设备检测, 有GPU的话将优先使用GPU
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    
    # 定义数据下载路径, 当前路径的data文件夹
    load_data_path = "./data"
    # 如果不存在该路径, 则创建这个路径
    if not os.path.isdir(load_data_path):
        os.mkdir(load_data_path)
    
    """
    注意：
        因为调用text_classification这个API的话，每次调用都会自动下载，因此修改text_classification其中的源码。
        首先拷贝一份text_classification.py修改为My_text_classification放到自己项目中，
        把所调用的底层中函数中的第一行download_from_url(URLS[dataset_name], root=root) 注释掉
    """
    # 选取torchtext中的文本分类数据集'AG_NEWS'即新闻主题分类数据, 保存在指定目录下
    # 并将数值映射后的训练和验证数据加载到内存中
    train_dataset, test_dataset = My_text_classification.DATASETS['AG_NEWS'](root=load_data_path)
    # train_dataset, test_dataset = text_classification.DATASETS['AG_NEWS'](root=load_data_path)
    
    class TextSentiment(nn.Module):
        def __init__(self, vocab_size, embed_dim, num_class):
            """
            :param vocab_size: 词汇表不重复单词总数，整个语料包含的不同词汇的总数
            :param embed_dim: 指定词嵌入的维度，一个单词的词嵌入维度
            :param num_class: 文本分类的类别总数
            """
            """
            1.EmbeddingBag API官方介绍：
                https://pytorch.org/docs/stable/nn.html?highlight=embeddingbag#torch.nn.EmbeddingBag
            2.torch.nn.EmbeddingBag(num_embeddings, embedding_dim, max_norm=None, norm_type=2.0, scale_grad_by_freq=False, 
                                    mode='mean', sparse=False, _weight=None)
                参数解释：
                    计算嵌入的“bags”的sums或means的方法，而不实例化中间嵌入embeddings。
                    对于长度恒定且无per_sample_weights的bags，该类
                    其中 mode="sum" 等于嵌入 Embedding 后跟 torch.sum(dim=0)
                    其中 mode="mean" 等于嵌入 Embedding 后跟 torch.mean(dim=0)
                    其中 mode="max" 等于嵌入 Embedding 后跟 torch.max(dim=0)
                使用：
                    embedding = nn.EmbeddingBag(vocab_size, embed_dim)  
                    embedding(input, offsets)
                参数解释：    
                    vocab_size: 词汇表不重复单词总数，整个语料包含的不同词汇的总数
                    embed_dim: 指定词嵌入的维度，一个单词的词嵌入维度
                    input：批量样本数据，用于准备输入到Embedding层中进行嵌入张量化
                    offsets：
                        offsets为一维张量，张量中每个值为每个句子头个单词在当前批量样本句子数据中的起始位置。
                        可以通过间接的方式计算出每个句子头个单词在当前批量样本句子数据中的起始位置，
                        首先计算出每个句子的长度，即每个句子中的单词数，然后通过cumsum函数可以计算出每个元素值的累计和，
                        比如[1.0, 2.0, 3.0] 通过cumsum函数计算出结果为[1., 3., 6.]，即每个元素值是第一个元素值到当前元素值的累计和，
                        那么便可以通过这种方式，传入每个句子的长度到cumsum函数计算出每个句子的累计和，
                        那么即得出每个句子在当前批量样本句子数据中的起始位置。
            3.例子
                >>> # vocab_size=10, embed_dim=3
                >>> embedding_sum = nn.EmbeddingBag(10, 3, mode='sum')
                >>> # 一个批量有2个样本，每个样本有4个数值
                >>> input = torch.LongTensor([1,2,4,5, 4,3,2,9])
                >>> #每个句子的头个单词的索引位置，即每个句子头个单词的起始位置
                >>> #offsets必须是1D张量，1D张量中每个值为input中每个bag(样本句子)的起始索引位置
                >>> #因为知道每个样本有4个数值，因此0为第一个句子头个单词的起始位置，4为第二个句子头个单词的起始位置
                >>> offsets = torch.LongTensor([0, 4])
                >>> embedding_sum(input, offsets)
                tensor([[-0.8861, -5.4350, -0.0523],
                        [ 1.1306, -2.5798, -1.0044]])
            """
            super().__init__()
            # 实例化embeddingBag层, sparse=True代表每次对该层求解梯度时, 只更新部分权重.
            self.embedding = nn.EmbeddingBag(vocab_size, embed_dim, sparse=False)
            # 实例化线性层, 参数分别是embed_dim和num_class.
            self.fc = nn.Linear(embed_dim, num_class)
            # 为各层初始化权重
            self.init_weights()
    
        def init_weights(self):
            """初始化权重函数"""
            # 指定初始权重的取值范围数
            initrange = 0.5
            # 各层的权重参数都是初始化为均匀分布
            self.embedding.weight.data.uniform_(-initrange, initrange)
            self.fc.weight.data.uniform_(-initrange, initrange)
            # 偏置初始化为0
            self.fc.bias.data.zero_()
    
        def forward(self, text, offsets):
            '''
            :param text: 批量句子样本的所有单词封装到一个一维张量中
            :param offsets:
                一维张量中的每个值为每个句子头个单词在当前批量样本数据中的起始位置，
                一维张量中的每个值也即是每个句子头个单词在text一维张量中的起始位置。
            :return: 真实类别标签值构成的一维张量，与类别数尺寸相同的张量, 用以判断文本类别
            '''
            # 获得embedding的结果embedded
            embedded = self.embedding(text, offsets)
            # 然后使用relu函数对输出进行处理，根据relu函数的特性, 将使Embedding矩阵更稀疏，以防止过拟合
            # embedded = F.relu(embedded)
            return self.fc(embedded)
    
    # 获得整个语料包含的不同词汇总数
    VOCAB_SIZE = len(train_dataset.get_vocab())
    # 获得类别总数
    NUN_CLASS = len(train_dataset.get_labels())
    # 实例化模型
    model = TextSentiment(VOCAB_SIZE, EMBED_DIM, NUN_CLASS).to(device)
    
    def generate_batch(batch):
        '''
        description: 生成batch数据函数
        :param batch: 由样本张量和对应标签的元组组成的batch_size大小的列表
                      形如: [(label1, sample1), (label2, sample2), ..., (labelN, sampleN)]
        :return:样本张量和标签各自的列表形式(张量)
                 形如:
                 text = tensor([sample1, sample2, ..., sampleN])
                 label = tensor([label1, label2, ..., labelN])
        '''
        # 从batch中获得标签张量，批量大小的真是类别标签值构成的一维向量
        label = torch.tensor([entry[0] for entry in batch])
        # 从batch中获得样本张量，批量大小句子样本数据构成的二维矩阵
        text = [entry[1] for entry in batch]
    
        """
        1.计算出offsets(每个句子头在当前批量样本数据中的起始位置，或者说每个句子头个单词在text一维张量中的起始位置)的步骤：
            1.第一步：第一个值必须是0，代表第一个句子头的起始位置，然后第二个值开始才是每个句子的长度值，即计算出每个句子的单词数
            2.第二步：
                通过cumsum函数可以计算出offsets一维张量中每个元素值的累计和，比如[1.0, 2.0, 3.0]通过cumsum函数计算出结果为[1., 3., 6.]。
                那么便可以通过计算累计和的方式 计算出每个句子头个单词在当前批量样本数据中的起始位置。
        2.标签值的计算
            把批量大小的样本真实标签值都封装到一个一维的张量中
        3.样本数据的计算
            首先获取出批量大小的样本句子数据所构建的二维张量，然后把二维张量通过cat函数合并为一维张量，
            即把每个句子的所有单词对应的索引值都合并到一个一维张量中。
        4.样本数据和offsets传入到embedding嵌入层中
            embedding(text, offsets)：可以直接把一维张量的样本数据text 和 一维张量的offsets 传入到embedding嵌入层中
        """
        # 计算出每个句子的单词数，即每个句子的长度，并且offsets的第一个必须为0，后面的值是每个句子的长度
        # 然后通过后面执行的cumsum函数根据offsets一维张量中的每个句子的长度 可以计算 元素的累计和，即可以计算出每个句子的头个单词在当前批量样本句子数据中的索引位置
        offsets = [0] + [len(entry) for entry in text]
        # print(offsets) #[0,。。。,。。。]
        # print(len(offsets)) # 17 即1 + batch size
    
        # torch.Tensor.cumsum 返回dim维度元素的累积和
        # torch.Tensor([1.0, 2.0, 3.0]).cumsum(dim=0) 输出结果为 tensor([1., 3., 6.])，即第二个元素为前两个元素的累计和，第三个元素是前三个元素的累计和
        offsets = torch.tensor(offsets[:-1]).cumsum(dim=0)
        # print("cumsum:",offsets) #每个元素值 是第一个元素到当前元素的累计和，因此就可以计算出每个句子的头个单词在当前批量样本句子数据中的索引位置
    
        #把批量样本数据(batch size个句子的单词索引值) 合并为 一个一维张量
        text = torch.cat(text)
        # print(text.shape) #一维张量的维度，每个张量的维度都不一致
    
        # 返回结果
        return text.to(device), offsets.to(device), label.to(device)
    
    # 导入torch中的数据加载器方法
    from torch.utils.data import DataLoader
    
    def train_func(sub_train_):
        """模型训练函数"""
        # 初始化训练损失和准确率为0
        train_loss = 0
        train_acc = 0
        # 使用数据加载器生成BATCH_SIZE大小的数据进行批次训练
        # data就是N多个generate_batch函数处理后的BATCH_SIZE大小的数据生成器
        # drop_last=True：丢弃不满足批量大小的批量数据，一般会是最后一个批量数据中的样本数可能不满足于批量大小，因此需要丢弃以防止报错
        data = DataLoader(sub_train_, batch_size=BATCH_SIZE, shuffle=True, collate_fn=generate_batch, drop_last=True)
        # collate_fn的输入是大小为batch_size的张量的列表，collate_fn将列表打包进最小批次（mini-batch）
        # 原始数据批次输入的文本条目被打包到一个列表并串联成了一个单独张量作为nn.EmbeddingBag的输入
        # 对data进行循环遍历, 使用每个batch的数据进行参数更新
        for i, (text, offsets, cls) in enumerate(data):
            # 设置优化器初始梯度为0
            optimizer.zero_grad()
            text, offsets, cls = text, offsets, cls
            # 模型输入一个批次数据, 获得输出
            output = model(text, offsets)
            # 根据真实标签与模型输出计算损失
            loss = criterion(output, cls)
            # 将该批次的损失加到总损失中
            train_loss += loss.item()
            # 误差反向传播
            loss.backward()
            # 参数进行更新
            optimizer.step()
            # 将该批次的准确率加到总准确率中
            train_acc += (output.argmax(1) == cls).sum().item()
    
        # 调整优化器学习率
        # scheduler.step()
    
        # 返回本轮训练的平均损失和平均准确率
        return train_loss / len(sub_train_), train_acc / len(sub_train_)
    
    def gotest_func(data_):
        """模型验证函数"""
        # 初始化验证损失和准确率为0
        loss = 0
        acc = 0
        # 和训练相同, 使用DataLoader获得训练数据生成器
        data = DataLoader(data_, batch_size=BATCH_SIZE, collate_fn=generate_batch, drop_last=True)
        # 按批次取出数据验证
        for text, offsets, cls in data:
            text, offsets, cls = text.to(device), offsets.to(device), cls.to(device)
            # 验证阶段, 不再求解梯度
            with torch.no_grad():
                # 使用模型获得输出
                output = model(text, offsets)
                # 计算损失
                loss = criterion(output, cls)
                # 将损失和准确率加到总损失和准确率中
                loss += loss.item()
                acc += (output.argmax(1) == cls).sum().item()
        # 返回本轮验证的平均损失和平均准确率
        return loss / len(data_), acc / len(data_)
    
    # 导入时间工具包
    import time
    # 导入数据随机划分方法工具
    from torch.utils.data.dataset import random_split
    # 定义初始的验证损失
    # min_valid_loss = float('inf')
    # 选择损失函数, 这里选择预定义的交叉熵损失函数
    criterion = torch.nn.CrossEntropyLoss().to(device)
    # 选择随机梯度下降优化器
    # optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate)
    # 选择优化器步长调节方法StepLR, 用来衰减学习率
    optimizer = torch.optim.Adam(model.parameters(),lr=learning_rate,betas=(0.9, 0.999), eps=1e-08, weight_decay=0, amsgrad=False)
    # scheduler = torch.optim.lr_scheduler.StepLR(optimizer, 1, gamma=0.9)
    # 从train_dataset取出0.95作为训练集, 先取其长度
    # train_len = int(len(train_dataset) * 0.95)
    train_len = int(len(train_dataset) * train_ratio)
    # 然后使用random_split进行乱序划分, 得到对应的训练集和验证集
    sub_train_, sub_valid_ = random_split(train_dataset, [train_len, len(train_dataset) - train_len])
    
    # 开始每一轮训练
    for epoch in range(N_EPOCHS):
        # 记录概论训练的开始时间
        start_time = time.time()
        # 调用train和valid函数得到训练和验证的平均损失, 平均准确率
        train_loss, train_acc = train_func(sub_train_)
        valid_loss, valid_acc = gotest_func(sub_valid_)
        # 计算训练和验证的总耗时(秒)
        secs = int(time.time() - start_time)
        # 用分钟和秒表示
        mins = secs / 60
        secs = secs % 60
        # 打印训练和验证耗时，平均损失，平均准确率
        print('Epoch: %d' %(epoch + 1), " | time in %d minutes, %d seconds" %(mins, secs))
        print(f'\tLoss: {train_loss:.4f}(train)\t|\tAcc: {train_acc * 100:.1f}%(train)')
        print(f'\tLoss: {valid_loss:.4f}(valid)\t|\tAcc: {valid_acc * 100:.1f}%(valid)')
    
    print('Checking the results of test dataset...')
    test_loss, test_acc = gotest_func(test_dataset)
    print(f'\tLoss: {test_loss:.4f}(test)\t|\tAcc: {test_acc * 100:.1f}%(test)')

--------------------

# **My\_text\_classification.py** #

import logging
    import torch
    import io
    from torchtext.utils import download_from_url, extract_archive, unicode_csv_reader
    from torchtext.data.utils import ngrams_iterator
    from torchtext.data.utils import get_tokenizer
    from torchtext.vocab import build_vocab_from_iterator
    from torchtext.vocab import Vocab
    from tqdm import tqdm
    
    URLS = {
        'AG_NEWS':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbUDNpeUdjb0wxRms',
        'SogouNews':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbUkVqNEszd0pHaFE',
        'DBpedia':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbQ2Vic1kxMmZZQ1k',
        'YelpReviewPolarity':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbNUpYQ2N3SGlFaDg',
        'YelpReviewFull':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbZlU4dXhHTFhZQU0',
        'YahooAnswers':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9Qhbd2JNdDBsQUdocVU',
        'AmazonReviewPolarity':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbaW12WVVZS2drcnM',
        'AmazonReviewFull':
            'https://drive.google.com/uc?export=download&id=0Bz8a_Dbh9QhbZVhsUnRWRDhETzA'
    }
    
    
    def _csv_iterator(data_path, ngrams, yield_cls=False):
        tokenizer = get_tokenizer("basic_english")
        with io.open(data_path, encoding="utf8") as f:
            reader = unicode_csv_reader(f)
            for row in reader:
                tokens = ' '.join(row[1:])
                tokens = tokenizer(tokens)
                if yield_cls:
                    yield int(row[0]) - 1, ngrams_iterator(tokens, ngrams)
                else:
                    yield ngrams_iterator(tokens, ngrams)
    
    
    def _create_data_from_iterator(vocab, iterator, include_unk):
        data = []
        labels = []
        with tqdm(unit_scale=0, unit='lines') as t:
            for cls, tokens in iterator:
                if include_unk:
                    tokens = torch.tensor([vocab[token] for token in tokens])
                else:
                    token_ids = list(filter(lambda x: x is not Vocab.UNK, [vocab[token]
                                            for token in tokens]))
                    tokens = torch.tensor(token_ids)
                if len(tokens) == 0:
                    logging.info('Row contains no tokens.')
                data.append((cls, tokens))
                labels.append(cls)
                t.update(1)
        return data, set(labels)
    
    
    class TextClassificationDataset(torch.utils.data.Dataset):
        """Defines an abstract text classification datasets.
           Currently, we only support the following datasets:
    
                 - AG_NEWS
                 - SogouNews
                 - DBpedia
                 - YelpReviewPolarity
                 - YelpReviewFull
                 - YahooAnswers
                 - AmazonReviewPolarity
                 - AmazonReviewFull
    
        """
    
        def __init__(self, vocab, data, labels):
            """Initiate text-classification dataset.
    
            Arguments:
                vocab: Vocabulary object used for dataset.
                data: a list of label/tokens tuple. tokens are a tensor after
                    numericalizing the string tokens. label is an integer.
                    [(label1, tokens1), (label2, tokens2), (label2, tokens3)]
                label: a set of the labels.
                    {label1, label2}
    
            Examples:
                See the examples in examples/text_classification/
    
            """
    
            super(TextClassificationDataset, self).__init__()
            self._data = data
            self._labels = labels
            self._vocab = vocab
    
        def __getitem__(self, i):
            return self._data[i]
    
        def __len__(self):
            return len(self._data)
    
        def __iter__(self):
            for x in self._data:
                yield x
    
        def get_labels(self):
            return self._labels
    
        def get_vocab(self):
            return self._vocab
    
    
    def _setup_datasets(dataset_name, root='.data', ngrams=1, vocab=None, include_unk=False):
        # dataset_tar = download_from_url(URLS[dataset_name], root=root)
    
        # dataset_tar = "./data/ag_news_csv.tar.gz"
        # extracted_files = extract_archive(dataset_tar)
    
        extracted_files =  ['./data/ag_news_csv/train.csv',
                            './data/ag_news_csv/test.csv',
                            './data/ag_news_csv/classes.txt',
                            './data/ag_news_csv/readme.txt']
    
        # print(extracted_files)
        for fname in extracted_files:
            if fname.endswith('train.csv'):
                train_csv_path = fname
            if fname.endswith('test.csv'):
                test_csv_path = fname
    
        if vocab is None:
            logging.info('Building Vocab based on {}'.format(train_csv_path))
            vocab = build_vocab_from_iterator(_csv_iterator(train_csv_path, ngrams))
        else:
            if not isinstance(vocab, Vocab):
                raise TypeError("Passed vocabulary is not of type Vocab")
        logging.info('Vocab has {} entries'.format(len(vocab)))
        logging.info('Creating training data')
        train_data, train_labels = _create_data_from_iterator(
            vocab, _csv_iterator(train_csv_path, ngrams, yield_cls=True), include_unk)
        logging.info('Creating testing data')
        test_data, test_labels = _create_data_from_iterator(
            vocab, _csv_iterator(test_csv_path, ngrams, yield_cls=True), include_unk)
        if len(train_labels ^ test_labels) > 0:
            raise ValueError("Training and test labels don't match")
        return (TextClassificationDataset(vocab, train_data, train_labels),
                TextClassificationDataset(vocab, test_data, test_labels))
    
    
    def AG_NEWS(*args, **kwargs):
        """ Defines AG_NEWS datasets.
            The labels includes:
                - 1 : World
                - 2 : Sports
                - 3 : Business
                - 4 : Sci/Tech
    
        Create supervised learning dataset: AG_NEWS
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.AG_NEWS(ngrams=3)
    
        """
    
        return _setup_datasets(*(("AG_NEWS",) + args), **kwargs)
    
    
    def SogouNews(*args, **kwargs):
        """ Defines SogouNews datasets.
            The labels includes:
                - 1 : Sports
                - 2 : Finance
                - 3 : Entertainment
                - 4 : Automobile
                - 5 : Technology
    
        Create supervised learning dataset: SogouNews
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.SogouNews(ngrams=3)
    
        """
    
        return _setup_datasets(*(("SogouNews",) + args), **kwargs)
    
    
    def DBpedia(*args, **kwargs):
        """ Defines DBpedia datasets.
            The labels includes:
                - 1 : Company
                - 2 : EducationalInstitution
                - 3 : Artist
                - 4 : Athlete
                - 5 : OfficeHolder
                - 6 : MeanOfTransportation
                - 7 : Building
                - 8 : NaturalPlace
                - 9 : Village
                - 10 : Animal
                - 11 : Plant
                - 12 : Album
                - 13 : Film
                - 14 : WrittenWork
    
        Create supervised learning dataset: DBpedia
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.DBpedia(ngrams=3)
    
        """
    
        return _setup_datasets(*(("DBpedia",) + args), **kwargs)
    
    
    def YelpReviewPolarity(*args, **kwargs):
        """ Defines YelpReviewPolarity datasets.
            The labels includes:
                - 1 : Negative polarity.
                - 2 : Positive polarity.
    
        Create supervised learning dataset: YelpReviewPolarity
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.YelpReviewPolarity(ngrams=3)
    
        """
    
        return _setup_datasets(*(("YelpReviewPolarity",) + args), **kwargs)
    
    
    def YelpReviewFull(*args, **kwargs):
        """ Defines YelpReviewFull datasets.
            The labels includes:
                1 - 5 : rating classes (5 is highly recommended).
    
        Create supervised learning dataset: YelpReviewFull
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.YelpReviewFull(ngrams=3)
    
        """
    
        return _setup_datasets(*(("YelpReviewFull",) + args), **kwargs)
    
    
    def YahooAnswers(*args, **kwargs):
        """ Defines YahooAnswers datasets.
            The labels includes:
                - 1 : Society & Culture
                - 2 : Science & Mathematics
                - 3 : Health
                - 4 : Education & Reference
                - 5 : Computers & Internet
                - 6 : Sports
                - 7 : Business & Finance
                - 8 : Entertainment & Music
                - 9 : Family & Relationships
                - 10 : Politics & Government
    
        Create supervised learning dataset: YahooAnswers
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.YahooAnswers(ngrams=3)
    
        """
    
        return _setup_datasets(*(("YahooAnswers",) + args), **kwargs)
    
    
    def AmazonReviewPolarity(*args, **kwargs):
        """ Defines AmazonReviewPolarity datasets.
            The labels includes:
                - 1 : Negative polarity
                - 2 : Positive polarity
    
        Create supervised learning dataset: AmazonReviewPolarity
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the datasets are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
           >>> train_dataset, test_dataset = torchtext.datasets.AmazonReviewPolarity(ngrams=3)
    
        """
    
        return _setup_datasets(*(("AmazonReviewPolarity",) + args), **kwargs)
    
    
    def AmazonReviewFull(*args, **kwargs):
        """ Defines AmazonReviewFull datasets.
            The labels includes:
                1 - 5 : rating classes (5 is highly recommended)
    
        Create supervised learning dataset: AmazonReviewFull
    
        Separately returns the training and test dataset
    
        Arguments:
            root: Directory where the dataset are saved. Default: ".data"
            ngrams: a contiguous sequence of n items from s string text.
                Default: 1
            vocab: Vocabulary used for dataset. If None, it will generate a new
                vocabulary based on the train data set.
            include_unk: include unknown token in the data (Default: False)
    
        Examples:
            >>> train_dataset, test_dataset = torchtext.datasets.AmazonReviewFull(ngrams=3)
    
        """
    
        return _setup_datasets(*(("AmazonReviewFull",) + args), **kwargs)
    
    
    DATASETS = {
        'AG_NEWS': AG_NEWS,
        'SogouNews': SogouNews,
        'DBpedia': DBpedia,
        'YelpReviewPolarity': YelpReviewPolarity,
        'YelpReviewFull': YelpReviewFull,
        'YahooAnswers': YahooAnswers,
        'AmazonReviewPolarity': AmazonReviewPolarity,
        'AmazonReviewFull': AmazonReviewFull
    }
    
    
    LABELS = {
        'AG_NEWS': {1: 'World',
                    2: 'Sports',
                    3: 'Business',
                    4: 'Sci/Tech'},
        'SogouNews': {1: 'Sports',
                      2: 'Finance',
                      3: 'Entertainment',
                      4: 'Automobile',
                      5: 'Technology'},
        'DBpedia': {1: 'Company',
                    2: 'EducationalInstitution',
                    3: 'Artist',
                    4: 'Athlete',
                    5: 'OfficeHolder',
                    6: 'MeanOfTransportation',
                    7: 'Building',
                    8: 'NaturalPlace',
                    9: 'Village',
                    10: 'Animal',
                    11: 'Plant',
                    12: 'Album',
                    13: 'Film',
                    14: 'WrittenWork'},
        'YelpReviewPolarity': {1: 'Negative polarity',
                               2: 'Positive polarity'},
        'YelpReviewFull': {1: 'score 1',
                           2: 'score 2',
                           3: 'score 3',
                           4: 'score 4',
                           5: 'score 5'},
        'YahooAnswers': {1: 'Society & Culture',
                         2: 'Science & Mathematics',
                         3: 'Health',
                         4: 'Education & Reference',
                         5: 'Computers & Internet',
                         6: 'Sports',
                         7: 'Business & Finance',
                         8: 'Entertainment & Music',
                         9: 'Family & Relationships',
                         10: 'Politics & Government'},
        'AmazonReviewPolarity': {1: 'Negative polarity',
                                 2: 'Positive polarity'},
        'AmazonReviewFull': {1: 'score 1',
                             2: 'score 2',
                             3: 'score 3',
                             4: 'score 4',
                             5: 'score 5'}
    }

[20191009191333910.png]: /images/20230528/72f9869eceb0418788f4bba3c86fc9bf.png
[Link 1]: http://www.rimengshe.com/
[AI_Keras PyTorch MXNet TensorFlow PaddlePaddle]: https://blog.csdn.net/zimiao552147572/article/details/88867161