目录

一.加载数据集

1.加载词汇表

2.构建一个简单分词器

3.打开评论文件路径并读取内容

4.将评论内容分词后作截断或填充操作

5.遍历填充或截断后的分词表，通过加载的字典来获取每个词对应的独热编码

6.打乱contents内容的顺序，划分数据集

7.返回值

二.数据类型定义

1.共享空间赋值

2.数据转化为张量

3.定义选代器对象的下一个元素

4.其他伴生方法

---

1. 数据加载器原理与实现路径

• 当前核心是讲解如何手动实现一个数据加载器，而不是直接使用PyTorch中的标准DataLoader。
• 实现的关键在于为数据集的对象定义一个__next__()方法，以便使其能够在for循环中被迭代。
• next()方法的作用是将数据转换为模型所需的输入格式（如X, Y），并将其以元组（tuple）形式返回。

2. 手动构建数据加载器的具体步骤

• 首先，在数据集中定义数据存储和随机化加载逻辑。
• 然后，通过实现类中的__next__()方法，遍历数据并将其按批次打包。
• 在返回batch数据时，需明确其内容构成，例如(batch_x, batch_y)或(batch_x, batch_y, length)，并确保数据已正确转换为张量（tensor）类型。
• 最终通过返回元组的方式，让外部的for循环可以正确地接收每一batch的数据。

from tqdm import tqdm
import pickle as pkl
import random
import torch
UNK,PAD='<UNK>','<PAD>'

一.加载数据集

1.加载词汇表

pad_size是每个评论的截断长度

def load_dataset(path,pad_size=70):
    contents=[]
    vocab=pkl.load(open('simplifyweibo_4_moods.pkl','rb'))

使用pickle的load()方法加载上一节保存的词表字典文件

2.构建一个简单分词器

    tokenizer=lambda x: [y for y in x]

这里就是简单将每一个字当作词划分

3.打开评论文件路径并读取内容

    with (open(path,'r',encoding='UTF-8') as f):
        i=0
        for line in tqdm(f):
            if i==0:
                i+=1
                continue
            if not line:
                continue
            label=int(line[0])
            content=line[2:].strip('\n')

label是标签

content是评论内容

4.将评论内容分词后作截断或填充操作

如果长度大于pad_size就截断反之填充‘<PAD>’字符        

            words_line=[]
            token=tokenizer(content)
            seq_len=len(token)
            if pad_size:
                if len(token)<pad_size:
                    token.extend([PAD]*(pad_size-len(token)))
                else:
                    token=token[:pad_size]
                    seq_len=pad_size

5.遍历填充或截断后的分词表，通过加载的字典来获取每个词对应的独热编码

            for word in token:
                words_line.append((vocab.get(word,vocab.get(UNK))))
            contents.append((words_line,int(label),seq_len))

向contents中添加该条评论每个词的独热编码列表和标签作为一个元组，与评论长度再组成一个元组返回        

6.打乱contents内容的顺序，划分数据集

前80%作为训练集

80%-90%作为验证集

90%-100%作为测试集

        random.shuffle(contents)#打乱顺序
        train_data=contents[:int(len(contents)*0.8)]
        dev_data=contents[int(len(contents)*0.8):int(len(contents)*0.9)]
        test_data=contents[int(len(contents)*0.9):]

7.返回值

        return vocab,train_data,dev_data,test_data

返回此表词表和各个数据集

二.数据类型定义

为了再接下来的模型训练过程中我们能够循环迭代的取出数据，所以我们自定义一种数据类型包含__next__()方法

1.共享空间赋值

class DatasetIterater(object):
    def __init__(self,batches,batch_size,device):
        self.batch_size=batch_size
        self.batches=batches
        self.n_batches=len(batches)//batch_size
        self.residue=False#记录划分后的数据是否存在剩余的数据
        if len(batches)%self.n_batches!=0:
            self.residue=True
        self.index=0
        self.device=device

batches是传进来的训练或测试数据

batch_size是每个批次的需要训练或测试的评论数据条数

n_batches是总共需要训练或测试的次数

residue记录划分后的数据是否存在剩余的数据

2.数据转化为张量

     def _to_tensor(self,datas):
        x=torch.LongTensor([_[0] for _ in datas]).to(self.device)#评论内容
        y=torch.LongTensor([_[1] for _ in datas]).to(self.device)#评论情感
        seq_len=torch.LongTensor([_[2] for _ in datas]).to(self.device)
        return (x,seq_len),y

3.定义选代器对象的下一个元素

--getitem__:是通过索引的方式获取数据对象中的内容。__next__ 是使用 for i in train_iter：迭代获取对象

    def __next__(self):#用于定义选代器对象的下一个元素。当一个对象实现了_next 方法时，它可以被用于创建迭代器对象。
        if self.residue and self.index==self.n_batches:#当读取到数据的最后一个batch:
            batches=self.batches[self.index*self.batch_size : len(self.batches)]
            self.index+=1
            batches=self._to_tensor(batches)
            return batches
        elif self.index>self.n_batches:#当读取完最后一个batch时:
            self.index=0
            raise StopIteration#为了防止迭代永远进行，我们可以使用StopIteration(停止迭代)语句
        else:#当没有读取到最后一个batch时:
            batches=self.batches[self.index*self.batch_size : (self.index+1)*self.batch_size]#提取当前bathsize的数据
            self.index+=1
            batches=self._to_tensor(batches)
            return batches

注意：这里是利用上面的方法将数据转化为张量再返回的

4.其他伴生方法

    def __iter__(self):
        return self

    def __len__(self):
        if self.residue:
            return self.n_batches+1
        else:
            return self.n_batches