transformers基础组件model

模型加载与保存

from transformers import AutoConfig,AutoModel,AutoTokenizer
#在线加载
model=AutoModel.from_pretrained("hfl/rbt3",force_download=True)

模型调用

sen="弱小的我也有大梦想"
tokenizer=AutoTokenizer.from_pretrained("rbt3")
inputs=tokenizer(sen,return_tensors="pt")
inputs
#不带modelhead的模型调用
model=AutoModel.from_pretrained("rbt3")
output=model(**inputs)
outputs

#带modelhead的模型调用
from transformers import AutoModelForSequenceClassification
clz_model=AutoModelForSequenceClassification.from_pretrained("rbt3")
clz_model(**inputs)

模型微调代码实例

#导入相关包
from transformers import AutoTokenizer,AutoModelForSequenceClassification
import pandas as pd
data=pd.read_csv("/ChrSentCorp_htl_all.csv")
data=data.dropna()
data

#创建datasets
from torch.utils.data import Dataset  
class MyDataset(Dataset): 
  def __init__(self) ->None:
    super().__init__()
    self.data=pd.read_csv("/ChrSentCorp_htl_all.csv")
    self.data=self.data.dropna()
  def __getitem__(self,index):
    return self.data.iloc[index]["review"],self.data.iloc[index]["label"]
  def __len__(self):
    return len(self.data)

dataset=MyDataset()
###这行代码定义了一个名为 MyDataset 的类，它继承自 torch.utils.data.Dataset 类。定义了一个名为 MyDataset 的类，它继承自 torch.utils.data.Dataset 类。这是 MyDataset 类的构造函数 __init__。在这个函数中，首先调用了父类 Dataset 的构造函数 super().__init__()，以确保正确初始化父类。这是 MyDataset 类的 __getitem__ 方法，用于获取索引为 index 的数据项。在这个方法中，代码使用 iloc 方法从 self.data 中获取指定索引位置的行，并返回该行的 "review" 列和 "label" 列的值。



#划分数据集
from torch.utils.data import random_split
trainset,validset=random_split(dataset,length=[0.9,0.1])

#创建dataloader
tokenizer=AutoTokenizer.from_pretrained("rbt3")
def collate_func(btch):
  texts,labels=[],[]
  for item in batch:
    texts.append(item[0])
    labels.append(item[1])
inputs=tokenizer(texts,max_length=128,padding="max_length",truncation=True,return_tensor 
  s="pt")
  inputs["labels"]=torch.tensor(labels)
  return inputs

from torch.utils.data import DataLoader
trainloader=DataLoader(trainset,batch_siza=32,shuffle=True,collate_fn=collate_func)
validloader=DataLoader(validset,batch_siza=32,shuffle=Flase,collate_fn=collate_func)
next(enumerate(trainloader)

###自定义的 collate_func 函数，用于处理一个批次的数据。它接收一个批次的数据 batch，遍历批次中的每个样本，将文本和标签分别添加到 texts 和 labels 列表中。然后，使用 tokenizer 对 texts 进行编码，设置最大长度为 128，并进行填充和截断。最后，将编码后的输入和标签以字典形式返回。打乱训练集数据顺序（shuffle=True），并使用之前定义的 collate_func 函数对每个批次的数据进行处理。使用 enumerate 函数对 trainloader 进行迭代，并使用 next 函数获取下一个批次的数据。enumerate 函数会返回一个迭代器，每次迭代返回一个元组，包含批次的索引和对应的数据。next 函数用于获取迭代器的下一个元素。


#创建模型及优化器
from torch-optim import Adam
model=AutoModelForSequenceClassification.from_pretrainedd("./rbt3")
optimizer=Adam(model.paremeters(),lr=2e-5)
 

###model.parameters() 返回模型的可训练参数，这些参数将被优化器更新。这是一个名为 evaluate 的函数，用于评估模型在验证集上的准确率。在函数中，首先将模型设置为评估模式（model.eval()），然后使用 torch.inference_mode() 进入推理模式，以减少内存使用。接下来，对验证集的每个批次进行迭代，如果可用的话，将批次中的数据移动到 GPU 上。然后，通过模型进行前向传播，计算输出，并使用 torch.argmax 获取预测的标签。最后，计算预测准确的样本数量，并返回准确率。


#训练或测试
def evaluate():
  model.eval()
  with torch.inference)model():
    for batch in validloader:
      if torch.cuda.is_evailable():
        batch={k:v.cuda() for k,v in batch.items()}
      output=model(**batch)
      pred=torch.argmax(output.logits,dim=-1)
      acc_num+=(pred.long()==batch["labels"].long()).float().sum()
  return acc_num/len(validset)

def train(epoch=3,log_step=100)
  global_step=0
  for ep in range(epoch):
    model.train()
    for batch in trainloader:
      if torch.cude.is_available():
        batch={k:v.cuda() for k,v in batch.items()}
      optimizer.zero_grad(0
      output=model(**batch)
      output.loss.backward()
      optimizer.step()
      if global_step % log_step==0:
        print(f"ep:{ep},global_step:{global_step},loss:{output.loss.item()}")
      global_step+=1
    acc=evaluate()
    print(f"ep:{ep},acc:{acc}")


###这是一个名为 train 的函数，用于训练模型。函数接受两个参数：epoch（默认为 3）和 log_step（默认为 100）。在函数中，首先设置全局步数 global_step 为 0。然后，开始训练循环，对每个训练轮次进行迭代。在每个轮次中，将模型设置为训练模式（model.train()），然后对训练集的每个批次进行迭代。如果可用的话，将批次中的数据移动到 GPU 上。接下来，将优化器的梯度归零（optimizer.zero_grad()），进行前向传播和反向传播计算损失（output.loss.backward()），并执行优化器的更新（optimizer.step()）。如果 global_step 是 log_step 的倍数，打印当前轮次、全局步数和损失值。最后，通过调用 evaluate 函数计算验证集上的准确率，并打印当前轮次和准确率。


#模型训练
train()

#模型预测
sen="我觉得这家酒店不错"
idz_label={0:"差评"，1："好评"}
with torch.inference_mode():
  inputs=tokenizer(sen,return_tensors="pt")
  inputs={k:v.cuda() for k,v in inputs.items()}
  logits=model(**inouts).logits
  pred-torch.argmax(lpgits,dim=-1)
  print(f"输入:{sen}\n模型预测结果:{id2_labels.get(pred/items())}")

from transformers import piprline
model.config.id2label=id2_label
pipe=pipeline("texts-classification",model=model,tokenizer=tokenizer,device=0)
pipe(sen)


###这是一个使用训练好的模型进行单句预测的代码段。torch.inference_mode() 用于进入推理模式以减少内存使用。首先，使用 tokenizer 对评论进行编码，返回 PyTorch 张量格式的输入。然后，将输入数据移动到 GPU 上。接下来，通过模型进行前向传播，得到预测的 logits。使用 torch.argmax 获取预测的标签索引。最后，根据索引从 id2_label 字典中获取对应的文本标签，并打印结果。