Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

你好请问代码中是否包含把微调后的模型保存下来的代码? import pandas as pd from sklearn import metrics from tqdm…

  1. User

    你好请问代码中是否包含把微调后的模型保存下来的代码? import pandas as pd from sklearn import metrics from tqdm import tqdm import numpy as np import os os.environ['CUDA_VISIBLE_DEVICES']='6'

    import torch from torch.utils.data import Dataset, DataLoader import torch.nn as nn import transformers

    from torch import cuda

    device = 'cuda' if cuda.is_available() else 'cpu'

    df_train = pd.read_csv("/data/fl/distillbert-qa/train.csv")[[ "id", "Ofiicial Account Name","Title","News Url","Image Url","Report Content","label"

    ]]

    def create_text(row): return (f"请判断以下新闻是真还是假,假新闻输出1,真新闻输出0.以下是一则新闻,新闻的账号发布信息为{row['Ofiicial Account Name']}," f"标题为{row['Title']},新闻链接为{row['News Url']}," f"标题图片链接为{row['Image Url']},举报内容为{row['Report Content']}.//")

    应用该函数到 DataFrame 的每一行,创建新的 'text' 列

    df_train['text'] = df_train.apply(create_text, axis=1)

    创建一个新的 DataFrame,只包含 'text' 和 'label' 列

    df_new = df_train[['text', 'label']]

    如果需要,可以将新的 DataFrame 保存为 CSV 文件

    df_new.to_csv("/data/fl/distillbert-qa/transformed_train.csv", index=False)

    显示前几行以确认结果

    print(df_new['text'].apply(len).max())

    print(df_new.head()) MAX_LEN = 512 BATCH_SIZE = 32 LEARNING_RATE = 1e-05

    DISTILL_BERT_PATH = '/data/fl/distillbert-qa/load' MODEL_PATH = "pytorch_model" tokenizer = transformers.DistilBertTokenizer.from_pretrained( DISTILL_BERT_PATH, do_lower_case=True )

    class tweet_Dataset(Dataset):

    def __init__(self, dataframe, tokenizer, max_len):
        self.data = dataframe
        self.tokenizer = tokenizer
        self.max_len = max_len
    
    def __getitem__(self, index):
        tweet = str(self.data.text[index])
        tweet = " ".join(tweet.split())
        inputs = self.tokenizer.encode_plus(tweet,
                                            None,
                                            add_special_tokens=True,
                                            max_length=self.max_len,
                                            pad_to_max_length=True,
                                            return_token_type_ids=True)
        ids = inputs['input_ids']
        mask = inputs['attention_mask']
        return {
            'ids': torch.tensor(ids, dtype=torch.long),
            'mask': torch.tensor(mask, dtype=torch.long),
            'labels': torch.tensor(self.data.label[index], dtype=torch.float)
        }
    
    def __len__(self):
        return len(self.data)
    

    train_size = 0.85 train_dataset=df_new.sample(frac=train_size,random_state=200).reset_index(drop=True) valid_dataset=df_new.drop(train_dataset.index).reset_index(drop=True)

    print("FULL Dataset: {}".format(df_new.shape)) print("TRAIN Dataset: {}".format(train_dataset.shape)) print("VALID Dataset: {}".format(valid_dataset.shape))

    training_set = tweet_Dataset(train_dataset, tokenizer, MAX_LEN) testing_set = tweet_Dataset(valid_dataset, tokenizer, MAX_LEN)

    training_set[0]

    train_params = {'batch_size': BATCH_SIZE, 'shuffle': True, 'num_workers': 0 }

    valid_params = {'batch_size': BATCH_SIZE, 'shuffle': True, 'num_workers': 0 }

    train_dl = DataLoader(training_set, **train_params) valid_dl = DataLoader(testing_set, **valid_params)

    class DistillBERTClass(torch.nn.Module): def init(self): super().init() self.distill_bert = transformers.DistilBertModel.from_pretrained(DISTILL_BERT_PATH) self.drop = torch.nn.Dropout(0.3) self.out = torch.nn.Linear(768, 1)

    def forward(self, ids, mask):
        distilbert_output = self.distill_bert(ids, mask)
        hidden_state = distilbert_output[0]  # (bs, seq_len, dim)
        pooled_output = hidden_state[:, 0]  # (bs, dim)
        output_1 = self.drop(pooled_output)
        output = self.out(output_1)
        return output
    

    model = DistillBERTClass() model.to(device)

    def loss_fn(outputs, labels): return nn.BCEWithLogitsLoss()(outputs, labels)

    optimizer = torch.optim.Adam(params=model.parameters(), lr=LEARNING_RATE)

    def eval_fn(data_loader, model): model.eval() fin_labels = [] fin_outputs = [] with torch.no_grad(): for bi, d in tqdm(enumerate(data_loader), total=len(data_loader)): ids = d["ids"] mask = d["mask"] labels = d["labels"]

            ids = ids.to(device, dtype=torch.long)
            mask = mask.to(device, dtype=torch.long)
            labels = labels.to(device, dtype=torch.float)
    
            outputs = model(ids=ids, mask=mask)
            fin_labels.extend(labels.cpu().detach().numpy().tolist())
            fin_outputs.extend(
                torch.sigmoid(outputs).cpu().detach().numpy().tolist())
        fin_outputs = np.array(fin_outputs) >= 0.5
        f1_score = metrics.f1_score(fin_labels, fin_outputs)
    return f1_score
    

    def fit(num_epochs, model, loss_fn, opt, train_dl, valid_dl):

    for epoch in range(num_epochs):
        model.train()
        for _,data in enumerate(train_dl, 0):
            ids = data['ids'].to(device, dtype = torch.long)
            mask = data['mask'].to(device, dtype = torch.long)
            labels = data['labels'].to(device, dtype = torch.float)
            outputs = model(ids, mask).squeeze()
            loss = loss_fn(outputs, labels)
            loss.backward()
            opt.step()
            opt.zero_grad()
    
        valid_acc = eval_fn(valid_dl, model)
        print('Epoch [{}/{}], Train Loss: {:.4f} and Validation acc {:.4f} and loss {:.4f}'.format(epoch+1, num_epochs, loss.item(),valid_acc, 1.1))
    

    fit(7, model, loss_fn, optimizer, train_dl, valid_dl)

    def sentence_prediction(sentence): max_len = MAX_LEN tweet = str(sentence) tweet = " ".join(tweet.split()) inputs = tokenizer.encode_plus( tweet, None, add_special_tokens=True, max_length=max_len, pad_to_max_length=True, )

    ids = inputs["input_ids"]
    mask = inputs["attention_mask"]
    
    ids = torch.tensor(ids, dtype=torch.long).unsqueeze(0)
    mask = torch.tensor(mask, dtype=torch.long).unsqueeze(0)
    
    ids = ids.to(device, dtype=torch.long)
    mask = mask.to(device, dtype=torch.long)
    
    outputs = model(ids=ids, mask=mask)
    
    outputs = torch.sigmoid(outputs).cpu().detach().numpy()
    return outputs[0][0] > 0.5
    
  2. Assistant

    您好!根据您提供的代码,当前并没有包含将微调后的模型保存下来的代码。为了保存训练好的模型,您可以使用 torch.save() 函数将模型的状态字典(state_dict)或整个模型进行保存。

    以下是两种常见的保存方式:

    1. 只保存模型的状态字典

    这是推荐的方式,因为它更灵活且与模型定义分离。

    # 在训练完成后添加保存模型状态字典的代码
    torch.save(model.state_dict(), 'distillbert_finetuned.pth')
    print("模型已保存为 distillbert_finetuned.pth")
    

    2. 保存整个模型

    这种方式将模型的结构和参数一起保存,但通常不推荐,因为在加载时需要确保模型结构代码的一致性。

    # 在训练完成后添加保存整个模型的代码
    torch.save(model, 'distillbert_finetuned_model.pth')
    print("整个模型已保存为 distillbert_finetuned_model.pth")
    

    如何集成到您的代码中

    可以在 fit 函数的训练循环结束后,或者在训练完成后添加保存模型的代码。例如:

    def fit(num_epochs, model, loss_fn, opt, train_dl, valid_dl):
        for epoch in range(num_epochs):
            model.train()
            for _, data in enumerate(train_dl, 0):
                ids = data['ids'].to(device, dtype=torch.long)
                mask = data['mask'].to(device, dtype=torch.long)
                labels = data['labels'].to(device, dtype=torch.float)
                outputs = model(ids, mask).squeeze()
                loss = loss_fn(outputs, labels)
                loss.backward()
                opt.step()
                opt.zero_grad()
    
            valid_acc = eval_fn(valid_dl, model)
            print('Epoch [{}/{}], Train Loss: {:.4f} and Validation acc {:.4f} and loss {:.4f}'.format(
                epoch+1, num_epochs, loss.item(), valid_acc, 1.1))
        
        # 训练结束后保存模型
        torch.save(model.state_dict(), 'distillbert_finetuned.pth')
        print("模型已保存为 distillbert_finetuned.pth")
    
    # 开始训练并保存模型
    fit(7, model, loss_fn, optimizer, train_dl, valid_dl)
    

    加载保存的模型

    如果您只保存了 state_dict,加载模型时需要先定义模型结构,然后加载状态字典:

    # 定义模型结构
    model = DistillBERTClass()
    model.to(device)
    
    # 加载状态字典
    model.load_state_dict(torch.load('distillbert_finetuned.pth'))
    model.eval()
    

    如果您保存了整个模型,可以直接加载:

    # 加载整个模型
    model = torch.load('distillbert_finetuned_model.pth')
    model.to(device)
    model.eval()
    

    总结

    当前代码中没有包含保存模型的部分。您可以根据上述方法,将保存模型的代码加入到训练流程的合适位置,以便在训练完成后保存您的微调模型。

    如果有其他问题,欢迎继续提问!