Kaggle - LLM Science Exam（一）：赛事概述、数据收集、BERT Baseline

已于 2023-10-29 04:22:41 修改
阅读量1.8k 收藏 6
点赞数 6
分类专栏： NLP 文章标签： bert 人工智能 nlp
于 2023-10-04 18:27:26 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56591814/article/details/133558648
版权

在这里插入图片描述

文章目录

  前言：国庆期间哪也没去，重装了win10，conda和python环境，然后重点解读Kaggle - LLM Science Exam赛事的优秀代码，希望可以学到些东西。

一、赛事概述

1.1 OpenBookQA Dataset

  OpenBookQA Dataset是由美国艾伦人工智能研究院（Allen Institute for AI）发布的一个问答技术评测集，其主要目的是通过选择题考试的方式来测试和评估人工智能系统的问题回答能力，以下是更详细的介绍。

  1. 发布背景
    许多之前的阅读理解数据集都是基于抽取式的方法,只需要从给定的上下文中抽取答案,而没必要进行更深层次的推理。OpenBookQA要求模型需要利用基础知识来回答问题,进行更复杂的推理。

  2. 数据集构成
    OpenBookQA包含5957个四选一的科学常识问题(4,957 train, 500 dev, 500 test)。这些问题需要根据包含1326个科学事实的小“书本”来回答。问题采样自维基百科页面。

  3. 模型表现
    回答OpenBookQA的问题不仅需要给定知识库中的科学常识，还需要额外的广泛常识知识。这些问题既不能通过检索算法回答正确，也不能通过词语共现算法回答正确。Strong neural baselines在OpenBookQA上只能达到约50%的准确率，与人类92%的准确率存在明显差距。

  4. 附加数据
    该数据集还提供了5167个群众贡献的常识知识,以及扩展的训练集、开发集、测试集，每个问题对应其所考察的核心科学事实、人类准确率、清晰度评分等信息。

  5. 数据集意义
    OpenBookQA推动了机器阅读理解从抽取式到推理式的发展，评估了模型在开放域知识下的深层理解和推理能力。

1.2 比赛背景

赛事地址：Kaggle - LLM Science Exam

  • LLM的能力：随着大型语言模型的能力不断扩展，研究领域中出现了使用LLMs来表征自身的趋势。因为许多现有的自然语言处理基准测试已经被最先进的模型轻松解决，所以有趣的工作是利用LLMs创建更具挑战性的任务，以测试更强大的模型。
  • 数据生成：比赛使用了gpt3.5模型，该模型基于从维基百科中提取的各种科学主题的文本片段，要求它编写一个多项选择问题（附带已知答案），然后过滤掉简单的问题。
  • 资源受限：本次比赛是一场代码比赛，GPU和时间都受到限制。
  • 挑战性：虽然量化和知识蒸馏等技术可以有效地缩小语言模型以便在更少的硬件资源上运行，但这场比赛仍旧充满挑战。目前，目前在 Kaggle 上运行的最大模型有大约 100 亿个参数，而 gpt3.5 有 1750 亿个参数。如果一个问答模型能够轻松通过一个比其规模大10倍以上的模型编写的问答测试，这将是一个真正有趣的结果。另一方面，如果更大的模型能够有效地难住较小的模型，这对LLMs自我评估和测试的能力具有引人注目的影响。
  • 竞赛旨在探讨比gpt3.5小10倍以上的问答模型能否有效回答gpt3.5编写的问题。结果将揭示LLM的基准测试和自我测试能力。

1.3 评估方法和代码要求

提交根据平均精度 @ 3 （MAP@3） 进行评估：
在这里插入图片描述

  其中 ，𝑈 为测试集中的问题数量，𝑃(𝑘) 为截断值为 𝑘 时的精确度，𝑛 为每个问题的预测数量，𝑟𝑒𝑙(𝑘) 为指示函数，如果排名为 𝑘 的项目是相关的（正确的）标签，则等于1，否则为0。

  另外，某个问题正确预测后，后续将跳过该标签的其他预测，以防止刷准确度。举例来说，假设有一个测试集，里面有3个问题的正确答案都是A，如果有一个模型对这3个问题给出以下答案，那么以下情况都会得到平均精确度1.0的分数：

[A, B, C, D, E] # 问题1预测
[A, A, A, A, A] # 问题2预测
[A, B, A, C, A] # 问题3预测

  这意味着一旦找到正确答案（A），之后的预测不再影响平均精确度分数。

  本次比赛必须以notebook提交，且CPU和GPU运行时间少于9小时。禁用互联网，但是允许使用公开的外部数据，包括预先训练的模型。另外提交文件必须命名为 submission.csv。

1.4 比赛数据集

  本次比赛是回答由gpt3.5模型生成的4000道多选题组成的测试集。测试集是隐藏的，当提交notebook后，才会有实际的测试数据进行评测。

  • train.csv ： 200个样本，问题+答案，以显示数据格式，并大致了解测试集中的问题类型。
  • test.csv ： 测试集，只包含题目，答案省略。
  • sample_submission.csv ： 提交格式示例

具体的训练集格式如下：

# Let's import the public training set and take a look
import pandas as pd

train_df = pd.read_csv('/kaggle/input/kaggle-llm-science-exam/train.csv')
train_df.head()

在这里插入图片描述
  对于测试集中的每个 id 标签，您最多可以预测 3 个标签 。submission.csv文件应包含header并具有以下格式：

id,prediction
0,	A B C
1,	B C A
2,	C A B
etc.

1.5 优秀notebook

  1. 《Starter Notebook: Ranked Predictions with BERT》：Bert Baseline，使用bert-base-cased和比赛提供的200个训练集样本进行训练，Public Score=0.545。

  2. 《[EDA, Data gathering] LLM-SE ~ Wiki STEM | 1k DS》（制作训练数据）：比赛提供的200个样本太少了，作者LEONID KULYK先分析了比赛数据集，然后同样使用 gpt3.5 制作了1000个Wikipedia样本，数据集上传在Wikipedia STEM 1k。

  3. 《LLM-SE ~ deberta-v3-large -i | 1k Wiki》:LEONID KULYK将自己收集的1000个Wikipedia样本和比赛训练集合并，一起训练，模型是deberta-v3-large。notebook中有最终模型权重，可直接推理，LB= 0.709。

  4. 《New dataset + DEBERTA v3 large training!》：0.723→0.759

  5. 《Open Book LLM Science Exam》：jjinho首次提出了Open Book方法，演示了如何在训练集中，使用faiss 执行相似性搜索，找到与问答数据最相似的context（Wikipedia数据），以增强问答效果。

  6. 《Open Book LLM Science Exam - Reduced RAM usage》：quangbk改进了方法5中的内存效率。

  7. 《OpenBook DeBERTaV3-Large Baseline (Single Model》)： Anil将方法4和方法6结合起来。他将先测试集数据按照方法6搜索出context，然后将其与prompt合并，得到新的测试集。然后加载方法4训练的模型进行推理，Public Score=0.771。

    test_df["prompt"] = test_df["context"] + " #### " +  test_df["prompt"]

  8. 《Sharing my trained-with-context model》：Mgoksu同样使用了方法7，只是使用了自己制作的数据集进行离线训练，得到一个更好的模型llm-science-run-context-2，然后进行推理，top public LB=0.807。

  9. 《How To Train Open Book Model - Part 1》、《How To Train Open Book Model - Part 2》：

    • CHRIS DEOTTE在part1中，参照方法8在自己制作的60k数据集进行训练，得到模型model_v2；然后在part2中使用方法8中的模型llm-science-run-context-2以及model_v2分别进行推理，得到的两个概率取平均，得到最终结果（Public Score=0.819）。
    • 在part1中，作者使用了竞赛指标MAP@3 来评估模型，并讨论了一些训练技巧，例如使用 PEFT或冻结model embeddings&model layers来减少训练参数、增加 LR 并减少 epochs来减少计算量、 使用gradient_checkpointing（这使用磁盘来节省RAM）、使用gradient_accumlation_steps模拟更大的批次等等。

  10. 《LLM Science Exam Optimise Ensemble Weights》：作者首先使用了方法9训练的模型权重；另外为了增加多样性，还融合了其它几个没有使用Open Book的deberta-v3-large模型，最终Public Score=0.837。作者还写了以下notebook：

  11. 《LLM-SciEx Optimise Ensemble Weights(better models)》：类似方法10，通过模型融合，Public Score=0.846。

  12. 《with only 270K articles》：作者自己制作了270K Wikipedia数据，使用LongFormer 模型而不是deberta-v3-large进行训练，Public Score=0.862。

  13. 《Platypus2-70B with Wikipedia RAG》：SIMJEG结合了方法8和12，最终Public Score=0.872。ALI在 《Explained Platypus2-70B + Wikipedia RAG》中对此notebook做了详细的说明。

二、BERT Baseline

  此部分参考《Starter Notebook: Ranked Predictions with BERT》，作者直接使用bert_base模型对训练集中的200个样本进行3个epoch的训练，然后再进行推理。大部分代码参考的是HF官方文档《Multiple choice》

2.1 数据预处理

import pandas as pd
from datasets import Dataset

train_df = pd.read_csv('/kaggle/input/kaggle-llm-science-exam/train.csv')
train_ds = Dataset.from_pandas(train_df)
train_df.head()

在这里插入图片描述


from transformers import AutoTokenizer

model_dir = 'bert-base-cased'
tokenizer = AutoTokenizer.from_pretrained(model_dir)

options = 'ABCDE'
indices = list(range(5))
option_to_index = {option: index for option, index in zip(options, indices)}
index_to_option = {index: option for option, index in zip(options, indices)}

def preprocess(example):
    # AutoModelForMultipleChoice 需要的是question/answer对，所以问题被复制5次
    first_sentence = [example['prompt']] * 5
    second_sentence = []
    # 遍历选项（A 到 E）并将它们添加到 second_sentence 列表中
    for option in options:
        second_sentence.append(example[option])

    tokenized_example = tokenizer(first_sentence, second_sentence, truncation=True)
    # 将答案映射为索引，并将其添加到 tokenized_example 中作为标签
    tokenized_example['label'] = option_to_index[example['answer']]
    return tokenized_example

# 使用数据集映射（map）预处理函数到训练数据集，同时删除不需要的列
tokenized_train_ds = train_ds.map(preprocess, batched=False, remove_columns=['prompt', 'A', 'B', 'C', 'D', 'E', 'answer'])
print(tokenized_train_ds[0])

{'id': 1, 'input_ids': [[101, 5979, ...], [101, 5979, ...], [101, 5979, ...], [101, 5979, ...], [101, 5979, ...]], 'token_type_ids': [[0, 0, ...], [0, 0, ...],[0, 0, ...],[0, 0, ...],[0, 0, ...]], 'attention_mask': [[1, 1,...],[1, 1,...],[1, 1,...],[1, 1,...],[1, 1,...]], 'label': 0}

  可以看到，每个样本的问题被重复5次后和5个选项合并，解码后的结果input_ids、token_type_ids、attention_mask都是5个元素的嵌套列表，等于一个样本被拆成5个样本。

有关填充和截断的详细信息，可参考官方文档《Padding and truncation》

2.2 定义data_collator

#  datacollator 来自 https://huggingface.co/docs/transformers/tasks/multiple_choice
# 每个batch中对问答对进行动态填充（dynamically pad），所以不需要将每个问答对都填充到模型最大序列长度
from dataclasses import dataclass
from transformers.tokenization_utils_base import PreTrainedTokenizerBase, PaddingStrategy
from typing import Optional, Union
import torch

@dataclass
class DataCollatorForMultipleChoice:
    tokenizer: PreTrainedTokenizerBase
    padding: Union[bool, str, PaddingStrategy] = True
    max_length: Optional[int] = None
    pad_to_multiple_of: Optional[int] = None
    
    def __call__(self, features):
        # features就是4个样本（batch size=4)
        label_name = "label" if 'label' in features[0].keys() else 'labels'
        # 对每个样本（feature，字典格式）使用pop删除key为label的键值对，返回被删除的值
        # 所以feature被删除了label键值对，而labels的值是四个样本label列表[0, 0, 1, 0]
        labels = [feature.pop(label_name) for feature in features] 
        batch_size = len(features)  						# 批次大小
        num_choices = len(features[0]['input_ids'])			# 选项数
        flattened_features = [
            [{k: v[i] for k, v in feature.items()} for i in range(num_choices)] for feature in features
        ]
        flattened_features = sum(flattened_features, [])
        
        batch = self.tokenizer.pad(
            flattened_features,
            padding=self.padding,
            max_length=self.max_length,
            pad_to_multiple_of=self.pad_to_multiple_of,
            return_tensors='pt',
        )
        batch = {k: v.view(batch_size, num_choices, -1) for k, v in batch.items()}
        batch['labels'] = torch.tensor(labels, dtype=torch.int64)
        return batch

  • 传入数据：features为四个样本数据，每个样本格式和tokenized_train_ds[0]的格式一样

    [{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...], 'label': 0}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...], 'label': 0}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...], 'label': 1}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...], 'label': 0}]

  • 去除label标签：labels = [feature.pop(label_name) for feature in features] ，通过字典的pop方法，去除了每个样本中的label键值对，并将label的值取出，最终labels=[0, 0, 1, 0]。这一步之后，每个feature为：

    {'input_ids': [[...], [...], [...], [...], [...]], 'token_type_ids': [[...], [...], [...], [...], [...]], 'attention_mask': [[...], [...], [...], [...], [...]]}

  • 执行flattened操作，此时flattened_features为：

    [[{'input_ids': ..., 'token_type_ids': ..., 'attention_mask': ...}, {...}, {...}, {...}, {...}], 
[{...}, {...}, {...}, {...}, {...}], 
[{...}, {...}, {...}, {...}, {...}],
 [{...}, {...}, {...}, {...}, {...}]]

  • sum(flattened_features, [])操作后，flattened_features为：

    # 加和操作后的flattened_features，成了20个样本
[{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, 
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]},
{'input_ids': [...], 'token_type_ids': [...], 'attention_mask': [...]}, ...]

这一步是将嵌套列表转为一维列表，方便后续解码时方便进行pad和batch操作。

  • 最终结果为：
{'input_ids': tensor([[[ 101, 2627...,    0]]]),
'token_type_ids': tensor([[[0, 0, 0,  ..., 0, 0]]]),
'attention_mask': tensor([[[1, 1, 1,  ..., 0, 0]]]),
'labels': tensor([0, 0, 1, 0])}

2.3 加载模型，配置trainer并训练

from transformers import AutoModelForMultipleChoice, TrainingArguments, Trainer
model = AutoModelForMultipleChoice.from_pretrained(model_dir)

output_dir = 'finetuned_bert'
training_args = TrainingArguments(
    output_dir=output_dir,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    load_best_model_at_end=True,
    learning_rate=5e-5,
    per_device_train_batch_size=4,
    per_device_eval_batch_size=4,
    num_train_epochs=3,
    weight_decay=0.01,
    report_to='none')

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train_ds,
    eval_dataset=tokenized_train_ds,
    tokenizer=tokenizer,
    data_collator=DataCollatorForMultipleChoice(tokenizer=tokenizer))

trainer.train()

Epoch	Training Loss	Validation Loss
1			No log			1.564447
2			No log			1.527968
3			No log			1.417341

2.4 预测结果并提交

  1. 直接使用trainer预测
test_df = pd.read_csv('/kaggle/input/kaggle-llm-science-exam/test.csv')
# 测试集没有answer列，加上这一列以保持和训练集格式一致，方便使用同样的处理方式
test_df['answer'] = 'A'  
test_ds = Dataset.from_pandas(test_df)
tokenized_test_ds = test_ds.map(preprocess, batched=False, remove_columns=['prompt', 'A', 'B', 'C', 'D', 'E', 'answer'])

test_predictions = trainer.predict(tokenized_test_ds) # 结果是PredictionOutput格式，包含predictions、label_ids、metrics三个字段
test_df.head()

在这里插入图片描述

import numpy as np
def predictions_to_map_output(predictions):
	# 对每一行的预测结果按照降序排列，并获取每行的前三个答案的索引
	# np.argsort默认是对列表中元素值进行升序排列，并返回排序后元素值对应的索引
    top_answer_indices = np.argsort(-predictions)[:,:3]
    top_answers = [' '.join([index_to_option[idx] for idx in row]) for row in top_answer_indices]
    return top_answers

# 获取测试集的id列，作为提交文件的id列
submission_df = test_df[['id']] 
submission_df['prediction'] = predictions_to_map_output(test_predictions.predictions)
submission_df.head()

	id	prediction
0	0	D B E
1	1	B A D
2	2	A C D
3	3	C D A
4	4	E D C
  1. 重新加载模型预测

可参考《LLM-SE ~ deberta-v3-large -i | 1k Wiki》

如果是重新打开notebook后再预测，需要先加载模型，设置推理的trainer参数再进行预测

from transformers import AutoModelForMultipleChoice, TrainingArguments, Trainer
model_checkpoint = "finetuned_bert/checkpoint-150"
model = AutoModelForMultipleChoice.from_pretrained(model_dir)
tokenizer = AutoTokenizer.from_pretrained(model_checkpoint)

# 只进行推理
inference_args = TrainingArguments(
    output_dir="./inference_results",  # 推理结果的保存目录
    per_device_eval_batch_size=8,     # 每个设备的推理批量大小
)

trainer = Trainer(
    model=model,                  # 已加载的模型
    tokenizer=tokenizer,
    args=inference_args,          # 推理的参数
    data_collator=DataCollatorForMultipleChoice(tokenizer=tokenizer)
)

test_predictions = trainer.predict(tokenized_test_ds)

后面的步骤都一样了。

三、 deberta-v3-large+ 1k Wiki（LB= 0.709）

参考《LLM-SE ~ deberta-v3-large -t | 1k Wiki》（训练）、 《LLM-SE ~ deberta-v3-large -i | 1k Wiki》（推理）

  LEONID KULYK使用自己收集的1000个Wikipedia样本和比赛训练集样本一起训练，模型是deberta-v3-large。主要训练代码为：

3.1 数据预处理

  1. 合并训练集样本和1k样本，划分训练集和验证集
stem_1k_df = pd.read_csv("/kaggle/input/wikipedia-stem-1k/stem_1k_v1.csv")

# 合并原训练集和1k数据集
new_train_df = pd.concat([train_df,stem_1k_df])
new_train_df.index = list(range(len(new_train_df)))
new_train_df.id = list(range(len(new_train_df)))
# 采样10%作为验证集，剩下90%为训练集，新的训练集共（1000+200）*0.9=1080条数据
eval_sampled_df = new_train_df.sample(frac=0.1, random_state=42)
train_sampled_df = new_train_df.drop(eval_sampled_df.index)

train_ds = Dataset.from_pandas(train_sampled_df)
eval_ds = Dataset.from_pandas(eval_sampled_df)
  1. 编码数据
model_dir = "microsoft/deberta-v3-large"
tokenizer = AutoTokenizer.from_pretrained(model_dir)
tokenized_train_ds = train_ds.map(preprocess, batched=False, remove_columns=['prompt', 'A', 'B', 'C', 'D', 'E', 'answer'])
tokenized_eval_ds = eval_ds.map(preprocess, batched=False, remove_columns=['prompt', 'A', 'B', 'C', 'D', 'E', 'answer'])

3.2 配置trainer参数，开启训练

  1. 配置wandb，跟踪训练
import os
from kaggle_secrets import UserSecretsClient
user_secrets = UserSecretsClient()		# 访问 存储在Kaggle Secrets 中的wandb KEY
# 将wandb KEY存储在环境变量 "WANDB_API_KEY" 中，方便后续创建wandb进程
os.environ['WANDB_API_KEY'] = user_secrets.get_secret("wandb_api")

在这里插入图片描述
2. 配置trainer参数，开启训练

model = AutoModelForMultipleChoice.from_pretrained(model_dir)

output_dir = 'finetuned_bert'
training_args = TrainingArguments(
    output_dir=output_dir,
    evaluation_strategy ="steps",
    eval_steps = 50, # Evaluation and Save happens every 5 steps
    save_steps = 50,
    save_total_limit = 3, # Only last 3 models are saved. Older ones are deleted
    logging_steps=1,
    load_best_model_at_end=True,
    learning_rate=3e-6,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=2,
    num_train_epochs=4,
    warmup_steps=50,
    report_to='wandb')

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=tokenized_train_ds,
    eval_dataset=tokenized_eval_ds,
    tokenizer=tokenizer,
    data_collator=DataCollatorForMultipleChoice(tokenizer=tokenizer))

trainer.train()

Step	Training Loss	Validation Loss
50		1.497800		1.607024
100		1.611300		1.604378
......
2100	1.110600		1.366213
2150	0.012100		1.371677

TrainOutput(global_step=2160, training_loss=1.018808510694308, metrics={'train_runtime': 1660.1988, 'train_samples_per_second': 2.602, 'train_steps_per_second': 1.301, 'total_flos': 1340019889268400.0, 'train_loss': 1.018808510694308, 'epoch': 4.0})

# 在当前目录保持模型
trainer.save_model(f'.')

3.3 推理（略）

四、 New dataset + DEBERTA v3 large training!（0.723→0.759）

参考《New dataset + DEBERTA v3 large training!》、

   Radek 基于上一章的deberta-v3-large+ 1k Wiki，使用自己生成的500个额外数据训练DEBERTA v3 large，Public Score=0.723。下面是主要方法：

# 拼接原训练集和自己的500条数据
df_train = pd.concat([
    df_train,
    pd.read_csv('/kaggle/input/additional-train-data-for-llm-science-exam/extra_train_set.csv'),
])
df_train.reset_index(inplace=True, drop=True)
df_train.shape

(700, 7)

model_dir = '/kaggle/input/deberta-v3-large-hf-weights'
model = AutoModelForMultipleChoice.from_pretrained(model_dir)
tokenizer = AutoTokenizer.from_pretrained(model_dir)

dataset = Dataset.from_pandas(df_train)
tokenized_dataset = dataset.map(preprocess, remove_columns=['prompt', 'A', 'B', 'C', 'D', 'E', 'answer'])

定义评估函数

def map_at_3(predictions, labels):
    map_sum = 0
    pred = np.argsort(-1*np.array(predictions),axis=1)[:,:3]
    for x,y in zip(pred,labels):
        z = [1/i if y==j else 0 for i,j in zip([1,2,3],x)]
        map_sum += np.sum(z)
    return map_sum / len(predictions)

def compute_metrics(p):
    predictions = p.predictions.tolist()
    labels = p.label_ids.tolist()
    return {"map@3": map_at_3(predictions, labels)}

model = AutoModelForMultipleChoice.from_pretrained(model_dir)

output_dir = 'finetuned_bert'
training_args = TrainingArguments(
    warmup_ratio=0.8,
    learning_rate=5e-6,
    weight_decay=0.01,
    per_device_train_batch_size=2,
    per_device_eval_batch_size=4,
    num_train_epochs=3,
    evaluation_strategy="epoch",
    save_strategy="epoch",
    report_to='none',
    load_best_model_at_end=True,
    output_dir=output_dir,
)



trainer = Trainer(
    model=model,
    args=training_args,
    tokenizer=tokenizer,
    data_collator=DataCollatorForMultipleChoice(tokenizer=tokenizer),
    train_dataset=tokenized_train_ds,
    eval_dataset=tokenized_train_ds,
    compute_metrics = compute_metrics
)

trainer.train()

Epoch	Training Loss	Validation Loss	Map@3
1		No log			1.588403	0.590714
2		1.609000		1.156294	0.790714
3		1.229900		0.480493	0.916190

TrainOutput(global_step=1050, training_loss=1.3934946659633092, metrics={'train_runtime': 476.6516, 'train_samples_per_second': 4.406, 'train_steps_per_second': 2.203, 'total_flos': 1004851100338920.0, 'train_loss': 1.3934946659633092, 'epoch': 3.0})

  可以看出，没有划分验证集，且使用了更小的学习率。

  Radek后来又生成了6000条数据，跟之前的500条融合为6.5K数据集，并在此基础上进行三次训练，得到了三个模型权重，上传在Science Exam Trained Model Weights中。然后通过下面两种方法，进行推理：

作者最后上传了15k high-quality train examples。

神洛华
关注
  • 6
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
kaggle-san-train-数据集
03-29
"kaggle-san-train-数据集"是Kaggle平台上一个广受欢迎的数据集，它为研究人员和实践者提供了丰富的数据资源，用于训练和构建智能模型。本文将对这个数据集进行深入解析，探讨其特点、结构以及可能的应用场景。 ...
Kaggle-Data-Science：Kaggle内核
03-04
【标题】"Kaggle-Data-Science：Kaggle内核" 涉及的知识点主要集中在数据科学领域，特别是在Kaggle平台上的实践应用。Kaggle是全球领先的数据科学竞赛平台，同时也是数据科学家和机器学习工程师分享、学习和协作的...
kaggle近三年NLP比赛top方案汇总及新赛推荐
学姐带你玩AI的博客
09-13 905
NLP的赛题任务主要有文本分类、情感分析、关系抽取、文本匹配、阅读理解、问答系统等，自Google开发的NLP处理模型BERT被广泛应用后，目前解决NLP任务的首选方案就是深度学习方法（textCNN、LSTM、GRU、BiLSTM、Attention等），至于用哪种方法，得要看具体的比赛要求。kaggle上NLP相关的比赛还是比较少的，我这次就整理了，有缺漏欢迎大家补充，金牌方案也全部分享出来了。整理好的比赛baseline以及开源代码合集文末直接领取。
kaggle大模型竞赛优胜方案总结与思考
hxshine的博客
10-17 587
比赛排行榜：总体上，RAG + LLM结合的模型可以在知识来源、检索方法、基座模型及其尺寸、是否需要微调等多个方面进行优化，针对本次比赛，对我收集到的一些方法进行对比，方便大家参考。RAG检索对于最终效果非常重要。包括不断优化检索数据质量，利用多种检索策略，基于传统方法（es，bm25，tfidf等），基于向量（开源方法，SimCSE训练），还可以通过ranker等方法筛选更好的结果都能带来不错的提升。如何有效的检索上下文知识，如何有效的处理长文本知识是难点，还有待进一步探索。
Kaggle最新赛事！附baseline详解！
最新发布
阿木寺的博客
04-28 210
今天解析一下Kaggle最新比赛：自动论文评分竞赛2.0——Learning Agency Lab - Automated Essay Scoring 2.0。文末有图书抽奖活动！本次比赛类型是自然语言处理NLP。目标是训练一个模型来为学生论文评分。本次比赛能帮助大家熟练使用bert等预训练语言模型。比赛4月初刚开始，难度适中，适合所有从事NLP相关工作的同学参加。有关本次比赛的baseline详...
【Kaggle竞赛】Kaggle竞赛了解
专注计算机视觉算法训练，算法优化部署以及SDK开发的知识分享。
02-18 6546
kaggle上的竞赛主要分为A类赛和B类赛。 A类赛主要适合用传统的机器学习算法做，偏向与文本数据处理，比如房价预测，文本分类等； B类赛则几乎都是用神经深度学习算法做，偏向于图像识别/目标检测等方向，比如基础的猫狗识别、cifar10图像分类、蛋白质识别等。根据我的亲身体验，真的需要配置好的服务器做基础才行啊！
[比赛简介]Kaggle - LLM Science Exam
Jiawen9的博客
07-16 746
kaggle新赛简介-Kaggle - LLM Science Exam
大模型Kaggle比赛首秀冠军方案总结
AI蜗牛车
10-29 399
两个月前Kaggle上了一个大模型的比赛，这也是Kaggle第一次举办和大模型相关的比赛，作为全程的观察员总结下这个比赛，从中看看大模型时代对NLP的竞赛有啥影响，以及大模型评测有什么参考和借鉴意义。链接www.kaggle.com/competitions/kaggle-llm-science-exam排行榜截图题目设定：和传统的大模型评测比较类似，给定的是科学类的题目和5个选项ABCDE，然...
深度学习——实战Kaggle比赛：预测房价
2301_78630677的博客
10-05 1325
经过前面两章理论知识的摧残后，终于到了最期待的实战环节了，本章将记录一下实战Kaggle比赛：预测房价。参考书：《动手学深度学习》本章跟着书中的操作复现了一遍，书中的代码的许多函数都是从零开始构建，跟之前学的直接引用模块中的函数不太一样。本章记录了如何加入一个Kaggle比赛，提交结果。在这个项目实战中，感觉就是用了很简单的线性模型（简单的了解了一下整个大概流程），从数据预处理到训练再到后面的参数调整。 寂兮寥兮，独立而不改，周行而不殆，可以为天下母。 --2023-10-5 进阶篇
Kaggle 大模型竞赛- LLM 科学考试LLM Science ExamUse LLMs to answer difficult science questions
人工智能曾小健
09-23 248
比赛目标受OpenBookQA 数据集的启发，本次竞赛要求参与者回答由大型语言模型编写的基于科学的困难问题。您的工作将帮助研究人员更好地了解法学硕士自我测试的能力，以及法学硕士可以在资源有限的环境中运行的潜力。语境。
kaggle-solutions:Ka Kaggle解决方案和想法:sports_medal:
04-27
最全面的Kaggle解决方案和想法清单 ••• 概述 此回购协议包含了过去Kaggle竞赛中表现最佳的人员几乎共享的所有可用解决方案和想法。 新比赛结束后，此列表将立即更新。 它使您可以搜索Kaggle过去的比赛解决方案和...
kaggle-allen-opensource:艾伦研究所Kaggle挑战赛的开源脚本等。 https
05-01
kaggle-allen-开源 艾伦研究所Kaggle挑战赛的开源脚本等。 ck12-fact-extractor.py 这摘录自“课程摘要”和“关键概念”电子书中的“事实” 跑步： 从ck12.org下载电子书（例如， ：//...
Kaggle-WhatsCooking-MachineLearning:随机森林分类器以食材为特征确定美食
05-08
数据文件概述 >>df_train.info() Int64Index: 39774 entries, 0 to 39773 Data columns (total 3 columns): cuisine 39774 non-null object id 39774 non-null int64 ingredients 39774 non-null object ...
Kaggle 知识点：物体检测赛题步骤
wzk4869的博客
09-17 601
Kaggle 知识点：物体检测赛题步骤
数据(机器学习/深度学习)竞赛平台——Kaggle
热门推荐
g11d111的博客
08-14 3万+
这篇文章适合那些刚接触Kaggle、想尽快熟悉Kaggle并且了解项目情况的朋友。本文分为两部分介绍Kaggle，Part One简单介绍Kaggle，Part Two将简单介绍正规的竞赛的项目，大家可以针对性的解决感兴趣的题目。 1、Kaggle简介Kaggle是一个数据分析的竞赛平台，网址：https://www.kaggle.com/企业或者研究者可以将数据、问题描述、期望的指标发布到Kagg
Kaggle 2022 年鉴发布！涵盖竞赛趋势 & 57场比赛方案汇总！
fengdu78的博客
01-03 1823
Kaggle比赛平台每年都会举办N多有价值的比赛，吸引了全球的用户参与。但作为参赛选手的你，你知道今年Kaggle最热门的比赛吗？今年最常见的比赛库是什么？90页竞赛年鉴领取方式见文末，Kaggle年鉴内容（2022年度）：比赛类型统计参赛选手统计模型&库统计比赛内容统计比赛类型统计2022年度举办57场比赛，共吸引了全球6万人次参加，总共提交方案84万次，总奖金162万美元。Featur...
Kaggle——海星目标检测比赛
qq_56591814的博客
10-02 4332
赛事地址：https://www.kaggle.com/c/tensorflow-great-barrier-reef 赛题目标：建立一个根据珊瑚礁水下视频训练的目标检测模型，实时准确地识别海星。澳大利亚美丽无比的大堡礁是世界上最大的珊瑚礁，有1500种鱼类、400种珊瑚、130种鲨鱼、鳐鱼和大量其他海洋生物。不幸的是，珊瑚礁正面临威胁，部分原因是一种特殊海星的数量过多，这种海星是吃珊瑚的刺海星冠（简称COTS）。
【数据竞赛】Kaggle知识点：比赛类型介绍
fengdu78的博客
07-15 7162
在Kaggle平台上，经常有好多个比赛可供选择。如下图所示，为正在进行比赛的截图。那么对于入门同学（从没参加过一次Kaggle比赛）如何选择一场适合的比赛呢？本文将对Kaggle平台上的...
关于做Kaggle比赛入门，看完这篇就够了
摩登都市天空---专栏
03-26 2万+
PART 0 : Kaggle 介绍 Kaggle的数据挖掘比赛近年来很火，以至于中国兴起了很多很多类似的比赛 Kaggle 是一个数据科学竞赛的平台，很多公司会发布一些接近真实业务的问题，吸引爱好数据科学的人来一起解决。https://www.kaggle.com/ 点击导航栏的 competitions 可以看到有很多比赛，其中正式比赛，一般会有奖金或者工作机会，除了正式比赛还有一些为初...
Kaggle中报错：E: Unable to locate package python-opengl
06-01
这个错误提示通常是因为你在 Kaggle 中尝试安装 python-opengl，但是该软件包在 Kaggle 环境中并不可用。 Kaggle 环境中已经预装了许多常用的 Python 库，包括 numpy、pandas、scikit-learn 等，但并不是所有的库都可以直接使用。如果你需要使用 python-opengl，可以考虑以下几种解决方案： 1. 尝试使用 Kaggle 环境中已经预装的 OpenGL 库，例如 pyopengl、pyopengl-accelerate 等。 2. 如果你需要使用 python-opengl 的特定功能，可以尝试使用其他库来代替。例如，如果你需要绘制 3D 图形，可以尝试使用 matplotlib、mayavi 等库。 3. 如果你一定需要使用 python-opengl，并且在 Kaggle 环境中无法正常安装，可以考虑使用其他云平台，例如 Google Colab、AWS 等。这些云平台提供了更为灵活的环境配置，可以自由安装需要的库和软件包。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

神洛华

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值