ormer

AI发布的一个问答技术评测集其主要目的是通过选择题考试的方式来测试和评估人工智能系统的问题回答能力以下是更详细的介绍。

发布背景

许多之前的阅读理解数据集都是基于抽取式的方法,只需要从给定的上下文中抽取答案,而没必要进行更深层次的推理。

OpenBookQA要求模型需要利用基础知识来回答问题,进行更复杂的推理。

数据集构成

OpenBookQA包含5957个四选一的科学常识问题(4,957

train,

test)。

这些问题需要根据包含1326个科学事实的小“书本”来回答。

问题采样自维基百科页面。

模型表现

回答OpenBookQA的问题不仅需要给定知识库中的科学常识还需要额外的广泛常识知识。

这些问题既不能通过检索算法回答正确也不能通过词语共现算法回答正确。

Strong

neural

baselines在OpenBookQA上只能达到约50%的准确率与人类92%的准确率存在明显差距。

附加数据

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

数据集意义

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

1.2

LLM的能力随着大型语言模型的能力不断扩展研究领域中出现了使用LLMs来表征自身的趋势。

因为许多现有的自然语言处理基准测试已经被最先进的模型轻松解决所以有趣的工作是利用LLMs创建更具挑战性的任务以测试更强大的模型。

数据生成比赛使用了gpt3.5模型该模型基于从维基百科中提取的各种科学主题的文本片段要求它编写一个多项选择问题附带已知答案然后过滤掉简单的问题。

资源受限本次比赛是一场代码比赛GPU和时间都受到限制。

挑战性虽然量化和知识蒸馏等技术可以有效地缩小语言模型以便在更少的硬件资源上运行但这场比赛仍旧充满挑战。

目前目前在

Kaggle

亿个参数。

如果一个问答模型能够轻松通过一个比其规模大10倍以上的模型编写的问答测试这将是一个真正有趣的结果。

另一方面如果更大的模型能够有效地难住较小的模型这对LLMs自我评估和测试的能力具有引人注目的影响。

竞赛旨在探讨比gpt3.5小10倍以上的问答模型能否有效回答gpt3.5编写的问题。

结果将揭示LLM的基准测试和自我测试能力。

1.3

另外某个问题正确预测后后续将跳过该标签的其他预测以防止刷准确度。

举例来说假设有一个测试集里面有3个问题的正确答案都是A如果有一个模型对这3个问题给出以下答案那么以下情况都会得到平均精确度1.0的分数

[A,

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

本次比赛必须以notebook提交且CPU和GPU运行时间少于9小时。

禁用互联网但是允许使用公开的外部数据包括预先训练的模型。

另外提交文件必须命名为

1.4

本次比赛是回答由gpt3.5模型生成的4000道多选题组成的测试集。

测试集是隐藏的当提交notebook后才会有实际的测试数据进行评测。

train.csv

200个样本问题答案以显示数据格式并大致了解测试集中的问题类型。

test.csv

测试集只包含题目答案省略。

sample_submission.csv

提交格式示例

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/train.csv)

个标签

。

submission.csv文件应包含header并具有以下格式

id,prediction

Baseline使用bert-base-cased和比赛提供的200个训练集样本进行训练Public

《[EDA,

DS》制作训练数据比赛提供的200个样本太少了作者LEONID

gpt3.5

制作了1000个Wikipedia样本数据集上传在Wikipedia

STEM

KULYK将自己收集的1000个Wikipedia样本和比赛训练集合并一起训练模型是deberta-v3-large。

notebook中有最终模型权重可直接推理LB

《New

Radek后来又生成了6000条数据跟之前的500条融合为6.5K数据集并在此基础上进行三次训练得到了三个模型权重上传在Science

Exam

Ensemble作者在这个notebook中详细介绍了Voting

high-quality

执行相似性搜索找到与问答数据最相似的contextWikipedia数据以增强问答效果。

《Open

Anil将方法4和方法6结合起来。

他将先测试集数据按照方法6搜索出context然后将其与prompt合并得到新的测试集。

然后加载方法4训练的模型进行推理Public

test_df[prompt]

model》Mgoksu同样使用了方法7只是使用了自己制作的数据集进行离线训练得到一个更好的模型llm-science-run-context-2然后进行推理top

public

DEOTTE在part1中参照方法8在自己制作的60k数据集进行训练得到模型model_v2然后在part2中使用方法8中的模型llm-science-run-context-2以及model_v2分别进行推理得到的两个概率取平均得到最终结果Public

Score0.819。

在part1中作者使用了竞赛指标MAP3

PEFT或冻结model

使用gradient_checkpointing这使用磁盘来节省RAM、使用gradient_accumlation_steps模拟更大的批次等等。

《LLM

Weights》作者首先使用了方法9训练的模型权重另外为了增加多样性还融合了其它几个没有使用Open

Book的deberta-v3-large模型最终Public

《Incorporate

Trainer》在Trainer中加入MAPk指标《Introducing

Adversarial

Inference》介绍对抗性权重扰动AWP以及推理方法。

《Using

DeepSpeed

模型而不是deberta-v3-large进行训练Public

《Platypus2-70B

RAG》SIMJEG结合了方法8和12一共18个版本Public

《Explained

articles!》在方法12的基础上改进了预处理函数并使用方法8

Score0.905

GPU和双线程来加速推理过程并微调了部分参数prepare_answering_input2最终LB0.904。

作者说自己参照方法11融合了另外6个模型最终得分0.916代码未公开。

[EDA,

本次比赛的数据集由GPT3.5生成的多项选择题组成数据是prompt问题

A、B、C、D

五个答案选项answer正确答案组成。

比赛目标是根据prompt预测前三个最可能的答案选项。

2.1

user_secrets.get_secret(openai_api)train_df

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/train.csv)

table

table_optionsdict(pageLength10))

fig

color_discrete_sequence[goldenrod])

fig.update_layout(showlegendFalse,xaxis_titleNumber

words,title{text:

本次比赛最重要的部分就是数据收集。

因此了解测试数据集是如何形成的以及如何重现其收集方法非常重要。

根据竞赛描述测试数据集是基于维基百科的页面形成的。

换句话说选择了关于科学、技术、工程和数学主题的页面重点是STEM中的S主题从中摘录了一段内容并将其传递到

GPT3.5

形成一个STEM科学、技术、工程和数学类别列表针对每个类别将搜索相应的页面以从中提取测试内容。

随机选择一个

主题从列表中随机选择一个类别。

获取所选类别的所有子类别和页面。

如果所选列表是子类别列表则选择随机子类别并转到上一步如果所选列表是页面列表则选择随机页面。

如果页面足够长

向LLM模型发送一条消息明确说明需要执行的任务并提供提取的文本。

包括指定要生成的多项选择题的数量、答案选项的长度或格式生成过程中提供一些指南或越苏例如提供有关问题和答案所需的风格、语气或复杂程度

options_set

get_completion_messages(wiki_text):return

{role:system,

f{delimiter}{wiki_text}{delimiter}},

]def

get_completion_from_messages(messages,

modelgpt-3.5-turbo,

openai.ChatCompletion.create(modelmodel,messagesmessages,temperaturetemperature,

response.choices[0].message[content]解析模型的输出并自动检查是否符合输出格式。

组合以上所有操作

最终作者根据以上思路基于250个维基百科Page生成了1000个训练数据数据集见数据集Wikipedia

STEM

API来从成千上万的文章中生成新问题会很昂贵。

为了确保我们只包括与任务相关的维基百科文章有两个主要因素a)

降低成本b)

比如我们知道这个竞赛是基于维基百科上科学类的文章那么训练数据不应包括历史类或地理类的文章。

即使如此维基百科上科学类文章还是有很多如果我们可以筛选出与竞赛相关的文章那将有助于减少模型中的噪声。

3.2

Analysis》中作者对包含了本次比赛训练数据的wikipedia

pages进行了分析目的找出哪些wikipedia类别最合适用来生成更多的训练数据。

作者采取了以下步骤

train_pages

conductivity,Superconductivity,Black

hole,Born

Model,Nebula,Antiferromagnetism,Light-year,Propagation

constant,Phase

rotation,Plant,Clockwise,Morphology

(biology),Magnetic

tolerance,Ferromagnetism,Coffee

ring

microbalance,Crystallinity,Magnitude

(astronomy),Newtons

entropy,Renormalization,Unified

field

energy,Baryogenesis,Pulsar,Decay

technique,Electric

density,Organography,Copernican

principle,Geometric

stability,Paramagnetism,Emissivity,Critical

Raw

]查找给定页面的类别我们使用BeautifulSoup来提取每个页面所属的类别而不依赖维基百科API因为API会返回一些不相关的隐藏类别。

组合图表使用

创建一个页面所属所有类别的图表得到包含所有页面和它们的类别关系的整体图表。

查找连接数量最多的类别对每个类别创建一个深度搜索优先树然后计算树中的Pages数量统计出每个类别链接了多少Pages。

计算类别的相关性得分很多类别链接的Pages都很多不足以进行分析。

我们计算每个类别与其连接的所有页面之间的最短距离的倒数之和将其做为“相关性得分”。

这个得分有两个影响因素

连接的页面数量如果一个类别与更多的页面连接那么它的得分将更高因为它涵盖了更多的内容。

连接距离如果一个类别与页面之间的连接是非常紧密的即它们之间的最短距离很小那么它的得分将更高。

这是因为这个类别更可能与页面内容直接相关。

top_leaf_connect_distances[:10]

[(Category:Concepts

59.0984126984127),(Category:Concepts

field,

42.90479797979802),(Category:Physics,

42.26829004329007),(Category:Subfields

physics,

37.716269841269835),(Category:Physical

sciences,

37.33095238095237),(Category:Subfields

academic

36.35238095238095),(Category:Physical

phenomena,

36.318253968253956),(Category:Main

topic

35.085714285714275),(Category:Concepts,

34.82943722943723),(Category:Physical

quantities,

34.773409923409915)]从上面可以看出“Concepts

physics”得分最高这个类别可以用于收集更多训练数据。

作者测试了仅通过“Concepts

physics”类别并在深度为1的情况下进行查询结果包含882个Pages其中包括了训练集中的111个Pages占总训练集的72%。

这大大减少了我们需要生成问题以生成额外训练数据的页面数量。

考虑到其它科学领域没有覆盖到您可以尝试探索图表中的其他类别并将其添加进来以查看是否可以覆盖更多的训练数据。

四、with

很多其他人分享的检索式代码都使用相对较小的文本编码器这些编码器在处理文章时可能性能较差。

同时考虑到所有的问题都是关于科学、技术、工程和数学STEM等主题的我们是否真的需要在整个维基百科上进行检索是否存在一些文章集合其中包含了绝大多数所需的信息

在《Finding

articles!》中作者基于上一章中的train_pages用于生成训练集数据的154篇维基百科文章列表以半监督的方式对维基百科文章进行KMeans聚类来获取

270K

解析中会丢失一些数字甚至段落这降低了检索增强模型的性能。

因此对于同一组文章作者使用

Wiki

/kaggle/input/faiss-gpu-173-python310/faiss_gpu-1.7.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl

!cp

/kaggle/input/sentence-transformers-222/sentence-transformers

/kaggle/working/sentence-transformers

!pip

/kaggle/working/sentence-transformers

!pip

/kaggle/input/blingfire-018/blingfire-0.1.8-py3-none-any.whl!pip

install

/kaggle/input/llm-whls/transformers-4.31.0-py3-none-any.whl

!pip

/kaggle/input/llm-whls/peft-0.4.0-py3-none-any.whl

!pip

/kaggle/input/llm-whls/trl-0.5.0-py3-none-any.whl!cp

/kaggle/input/datasets-wheel/datasets-2.14.4-py3-none-any.whl

/kaggle/working

/kaggle/working/datasets-2.14.4-py3-none-any.whl

!cp

/kaggle/input/backup-806/util_openbook.py

.import

generate_openbook_outputget_contexts()

generate_openbook_output()gc.collect()这一步是执行util_openbook.py中的两个函数

get_contexts()使用faiss对测试集的prompt进行向量检索检索出最相似的维基百科上下文contentgenerate_openbook_output()将content与prompt合并再使用llm-science-run-context-2模型进行解码和推理结果处理成比赛要求的格式保存到submission_backup.csv文件中。

《Sharing

QAdebertav3-large详解》中对代码进行了详细的解读可供参考。

import

sklearn.feature_extraction.text

import

unicodedatabackup_model_predictions

pd.read_csv(submission_backup.csv)

backup_model_predictions.head()id

prediction

/kaggle/input/stem-wiki-cohere-no-emb

/kaggle/working

/kaggle/input/all-paraphs-parsed-expanded

检索相关文档

sklearn.feature_extraction.text

import

chunk_size):将输入的列表分割成大小为chunk_size的块。

参数mylist

(list):

get_relevant_documents_parsed(df_valid):根据df_valid获取相关文档的解析内容。

参数df_valid

(DataFrame):

从磁盘加载已解析的语料库数据集paraphs_parsed_dataset

load_from_disk(/kaggle/working/all-paraphs-parsed-expanded)#

paraphs_parsed_dataset.map(lambda

example:{temp_text:f{example[title]}

{example[section]}

).replace(,)},num_proc2)[temp_text]#

初始化用于存储结果的空列表all_articles_indices

[]#

创建一个进度条遍历整个数据框架按照指定的切块大小进行迭代for

idx

函数获取相关文章的索引和分数articles_indices,

merged_top_scores

将当前切块的结果添加到相应的列表中all_articles_indices.append(articles_indices)all_articles_values.append(merged_top_scores)#

将各个切块的结果合并成单个数组article_indices_array

np.concatenate(all_articles_indices,

np.concatenate(all_articles_values,

axis0).reshape(-1)#

article_indices_array.shape[1]#

[(articles_values_array[index],paraphs_parsed_dataset[idx.item()][title],paraphs_parsed_dataset[idx.item()][text],)for

index,idx

enumerate(article_indices_array.reshape(-1))]#

SplitList

函数将结果分割成适当的块并返回retrieved_articles

top_per_query)return

get_relevant_documents(df_valid):根据有效数据框架df_valid获取相关文档。

参数df_valid

(DataFrame):

从磁盘加载已过滤的语料库数据集cohere_dataset_filtered

load_from_disk(/kaggle/working/stem-wiki-cohere-no-emb)#

cohere_dataset_filtered.map(lambda

example:{temp_text:unicodedata.normalize(NFKD,

f{example[title]}

{example[text]}).replace(,)},num_proc2)[temp_text]#

初始化用于存储结果的空列表all_articles_indices

[]#

创建一个进度条遍历整个数据框架按照指定的切块大小进行迭代for

idx

函数获取相关文章的索引和分数articles_indices,

merged_top_scores

将当前切块的结果添加到相应的列表中all_articles_indices.append(articles_indices)all_articles_values.append(merged_top_scores)#

将各个切块的结果合并成单个数组article_indices_array

np.concatenate(all_articles_indices,

np.concatenate(all_articles_values,

axis0).reshape(-1)#

article_indices_array.shape[1]#

[(articles_values_array[index],cohere_dataset_filtered[idx.item()][title],unicodedata.normalize(NFKD,

cohere_dataset_filtered[idx.item()][text]),)for

index,idx

enumerate(article_indices_array.reshape(-1))]#

SplitList

函数将结果分割成适当的块并返回retrieved_articles

top_per_query)return

modified_texts):根据df_valid和修改后的文本获取相关文档。

参数df_valid

(DataFrame):

row:f{row[prompt]}\n{row[prompt]}\n{row[prompt]}\n{row[A]}\n{row[B]}\n{row[C]}\n{row[D]}\n{row[E]},axis1).values#

创建一个

TfidfVectorizer(ngram_range(1,2),token_patternr(?u)\b[\w/.-]\b|!|/|\?|\|\,stop_wordsstop_words)#

用语料库内容拟合第一个

vectorizervectorizer1.fit(corpus_df_valid)vocab_df_valid

vectorizer1.get_feature_names_out()#

创建另一个

TfidfVectorizer(ngram_range(1,2),token_patternr(?u)\b[\w/.-]\b|!|/|\?|\|\,stop_wordsstop_words,vocabularyvocab_df_valid)#

500,000

vectorizervectorizer.fit(modified_texts[:500000])#

TF-IDF

vectorizer.transform(corpus_df_valid)#

vectorizer

{len(vectorizer.get_feature_names_out())})#

定义块的大小、每块的前N个最高分数以及每个查询的前N个最高分数chunk_size

100000top_per_chunk

初始化存储每个块的顶部索引和值的列表all_chunk_top_indices

[]#

vectorizer.transform(modified_texts[idx:

idxchunk_size])#

找到每个查询的前N个最高分数的索引chunk_top_indices

temp_scores.argpartition(-top_per_chunk,

axis1)[:,

temp_scores[np.arange(temp_scores.shape[0])[:,

np.newaxis],

将当前块的顶部索引和值添加到相应的列表中all_chunk_top_indices.append(chunk_top_indices

idx)all_chunk_top_values.append(chunk_top_values)#

将所有块的顶部索引和值合并成单个数组top_indices_array

np.concatenate(all_chunk_top_indices,

np.concatenate(all_chunk_top_values,

axis1)#

对合并的顶部值进行排序仅保留每个查询的前N个最高分数merged_top_scores

找到每个查询的前N个最高分数的索引merged_top_indices

top_values_array.argsort(axis1)[:,-top_per_query:]#

构建文章索引数组以获取相关文章的索引articles_indices

top_indices_array[np.arange(top_indices_array.shape[0])[:,

np.newaxis],

merged_top_scores上述函数用来检索与测试集问答数据相关的文档下面逐一分解这些函数及其用途

SplitList(mylist,

将列表分割成指定大小chunk_size的较小块最终返回一个包含列表块的列表。

get_relevant_documents_parsed(df_valid):

这个函数以一个DataFrame(df_valid)作为输入检索一组问题的相关文章

加载paraphs_parsed_dataset数据集包含经过预处理的文本信息。

它通过连接标题、章节和文本字段以及删除换行符和单引号来修改paraphs_parsed_dataset中的文本。

它初始化空列表以存储文章索引和值。

它按照大小为df_chunk_size的块迭代DataFrame

df_valid其中每个块代表一组问题。

对于每个问题块它使用检索函数retrieval获得的文章索引和值并附加到相应的列表。

处理完所有块后它将文章索引和值连接成数组并将结果格式化为一系列相关文章的列表。

函数返回相关文章的列表。

get_relevant_documents(df_valid):

这个函数类似于get_relevant_documents_parsed但它加载不同的数据集(“cohere_dataset_filtered”)并使用不同的文本预处理方法。

retrieval(df_valid,

这个函数执行基于问题和预处理文本的实际文档检索。

以下是其功能的详细说明

它准备了一个TF-IDF矢量化器并根据指定的参数在预处理文本上进行拟合。

它计算了df_valid中问题的TF-IDF向量。

它将TF-IDF计算划分为大小为chunk_size的块并分别处理每个块。

对于每个块它计算问题的TF-IDF向量与预处理文本的TF-IDF向量之间的余弦相似性分数。

它选择具有最高相似性分数的每个问题的前文档。

它返回所选文章的索引以及相应的相似性分数。

最后当调用get_relevant_documents_parsed(df_valid)时它通过利用上述函数来检索

与df_valid中的问题相关的文章。

针对df_valid中的每组问题这些文章被组织成块。

stop_words

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/train.csv)

test_df

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/test.csv)

train_df.iloc[:,:7].equals(test_df)Trueretrieved_articles_parsed

get_relevant_documents_parsed(test_df)try:with

open(retrieved_articles_parsed.pkl,

wb)

pickle_file:pickle.dump(retrieved_articles_parsed,

pickle_file)print(保存retrieved_articles_parsed成功)

except

捕获异常并打印错误信息print(保存retrieved_articles_parsed出错:,

str(e))gc.collect()retrieved_articles_parsed[0]#

一共10篇相关文章及其标题和分数

MOND.),(0.3153668078674981,Atom,Up

95%

get_relevant_documents(test_df)

try:with

pickle_file:pickle.dump(retrieved_articles,

pickle_file)print(保存retrieved_articles成功)

except

捕获异常并打印错误信息print(保存retrieved_articles出错:,

str(e))

gc.collect()retrieved_articles[0]#

一共10篇相关文章及其标题和分数

[(0.2950371392568642,Intracluster

medium,Measurements

clusters.),(0.29527605466122714,Modified

Newtonian

open(/kaggle/input/retrieved-articles/retrieved_articles/retrieved_articles_parsed.pkl,

rb)

pickle_file:retrieved_articles_parsed

pickle.load(pickle_file)print(加载retrieved_articles_parsed成功)with

open(/kaggle/input/retrieved-articles/retrieved_articles/retrieved_articles.pkl,

rb)

pickle.load(pickle_file)print(加载retrieved_articles成功)#

加载训练集、测试集

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/train.csv)

test_df

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/test.csv)4.2.3

定义预处理函数和评测指标

下面的函数是将之前检索的相似文档context和每个测试样本的question进行合并再复制5次得到c_plus_q_5对应五个问题选项。

然后解码c_plus_q_5和options都是长为5的列表最后只保留input_ids和attention_mask。

def

prepare_answering_input(tokenizer,

question,

max_seq_length4096,):准备用于回答问题的输入编码包括问题、选项、上下文等信息。

参数tokenizer

(Tokenizer):

包含编码输入的字典包括输入的ID和注意力掩码。

注意此函数用于将问题、选项和上下文组合成一个输入编码以供后续用于问题回答任务。

#

context

使用分词器对组合字符串和选项进行编码tokenized_examples

options,max_lengthmax_seq_length,paddinglongest,truncationFalse,return_tensorspt,)#

tokenized_examples[input_ids].unsqueeze(0)attention_mask

tokenized_examples[attention_mask].unsqueeze(0)#

{input_ids:

input_ids.to(model.device.index),attention_mask:

attention_mask.to(model.device.index),}#

example_encodeddef

[np.argsort(-np.array(prob))[:3]

for

predict(df,prepare):probability

预测结果概率submit_ids

tqdm(range(df.shape[0])):columns

df.iloc[index].valuessubmit_ids.append(columns[0])question

columns[1]options

测试集相似文章在articles_list列表第三个、第四个变量test_articles,test_articles_parsedcontext1

\n.join([retrieved_articles[index][-i][2]

for

\n.join([retrieved_articles_parsed[index][-i][2]

for

questionquestion,optionsoptions,

questionquestion,optionsoptions,

model(**inputs1)

-outputs1.logits[0].detach().cpu().numpy()probability1

torch.softmax(torch.tensor(-losses1),

dim-1)with

-outputs2.logits[0].detach().cpu().numpy()probability2

torch.softmax(torch.tensor(-losses2),

dim-1)probability_

probability2torch.cuda.empty_cache()

释放GPU内存#

如果预测概率大于0.4就保留结果否则采用backup_model_predictions中的预测结果相当于集成两个模型的结果if

probability_.max()

np.array(list(ABCDE))[np.argsort(probability_)][-3:].tolist()[::-1]else:predict

backup_model_predictions.iloc[index].prediction.replace(

,)probability.append(probability_)result.append(predict)return

transformers

model_dir/kaggle/input/longformer-race-model/longformer_qa_modeltokenizer

LongformerTokenizer.from_pretrained(model_dir)

model

LongformerForMultipleChoice.from_pretrained(model_dir).cuda()

probability,resultpredict(test_df,prepare_answering_input)result

.join(i)

pd.DataFrame({id:train_df.id,prediction:result}).to_csv(submission.csv,

indexFalse)

prepare_answering_input(tokenizer,

question,

options,max_lengthmax_seq_length,paddinglongest,truncationonly_first,return_tensorspt,add_special_tokensFalse)input_ids

tokenized_examples[input_ids].unsqueeze(0)attention_mask

tokenized_examples[attention_mask].unsqueeze(0)example_encoded

{input_ids:

input_ids.to(model.device.index),attention_mask:

attention_mask.to(model.device.index),}return

example_encoded单模型run-context-valid-loss得分0.896此作者在《Sharing

trained-with-context

model》中发布了模型llm-science-run-context-2下面几个应该是作者炼的相似模型。

model_paths

/kaggle/input/llm-science-run-context-2,

80.6

/kaggle/input/llm-science-run-context-3/fold_0,

80.6/kaggle/input/llm-science-run-context-3/fold_1,

81.0

/kaggle/input/llm-science-run-context-3/fold_2,

79.9

/kaggle/input/llm-science-run-context-3/fold_3,

80.1

/kaggle/input/llm-science-run-context-3/fold_4,

80.0

/kaggle/input/llm-science-run-context-3/fold_5,

79.8/kaggle/input/llm-science-run-context-4/fold_0,

81.8

/kaggle/input/llm-science-run-context-4/fold_1,

79.9

/kaggle/input/llm-science-run-context-5/fold_0,

81.3/kaggle/input/run-context-valid-loss,

/kaggle/input/run-context2-valid-loss,#

/kaggle/input/llm-science-run-context-5/fold_1,

/kaggle/input/run-context-all-mpnet-base-v2-map3/0,

/kaggle/input/run-context-all-mpnet-base-v2-loss/0,

/kaggle/input/run-context-all-mpnet-base-v2-valid-loss,

]all_probs

AutoTokenizer.from_pretrained(model_path)model

AutoModelForMultipleChoice.from_pretrained(model_path).cuda()for

index

tqdm(range(df_valid.shape[0])):columns

df_valid.iloc[index].valuesquestion

columns[1]options

\n.join([retrieved_articles[index][-1-i][2]

for

\n.join([retrieved_articles_parsed[index][-1-i][2]

for

prepare_answering_input(tokenizertokenizer,

questionquestion,optionsoptions,

prepare_answering_input(tokenizertokenizer,

questionquestion,optionsoptions,

model(**inputs1)

-outputs1.logits[0].detach().cpu().numpy()probability1

torch.softmax(torch.tensor(-losses1),

dim-1)with

-outputs2.logits[0].detach().cpu().numpy()probability2

torch.softmax(torch.tensor(-losses2),

dim-1)probability_

probability2)/2probs.append(probability_)all_probs.append(probs)all_preds

for

all_preds.mean(0)predictions_as_ids

np.array(list(ABCDE))[predictions_as_ids]

df_valid[prediction]

predictions_as_answer_letters[:,

:3]

submission.to_csv(submission.csv,

indexFalse)4.4

不需要运行util_openbook.py即不需要backup_model_predictions模型改为方法9

《How

large模型权重见how-to-train-open-book-model-part-1。

采用

RAPIDS

/kaggle/input/datasets-wheel/datasets-2.14.4-py3-none-any.whl

/kaggle/working)

/kaggle/working/datasets-2.14.4-py3-none-any.whl)

os.system(pip

/kaggle/input/llm-whls/transformers-4.31.0-py3-none-any.whl)os.system(cp

/kaggle/input/stem-wiki-cohere-no-emb

/kaggle/working)

/kaggle/input/all-paraphs-parsed-expanded

numpy

get_relevant_documents_parsed(df_valid):df_chunk_size600paraphs_parsed_dataset

load_from_disk(/kaggle/working/all-paraphs-parsed-expanded)modified_texts

paraphs_parsed_dataset.map(lambda

example:{temp_text:f{example[title]}

{example[section]}

).replace(,)},num_proc2)[temp_text]all_articles_indices

[]for

idxdf_chunk_size]articles_indices,

merged_top_scores

modified_texts)all_articles_indices.append(articles_indices)all_articles_values.append(merged_top_scores)article_indices_array

np.concatenate(all_articles_indices,

np.concatenate(all_articles_values,

axis0).reshape(-1)top_per_query

article_indices_array.shape[1]articles_flatten

[(articles_values_array[index],paraphs_parsed_dataset[idx.item()][title],paraphs_parsed_dataset[idx.item()][text],)for

index,idx

enumerate(article_indices_array.reshape(-1))]retrieved_articles

top_per_query)return

get_relevant_documents(df_valid):df_chunk_size800cohere_dataset_filtered

load_from_disk(/kaggle/working/stem-wiki-cohere-no-emb)modified_texts

cohere_dataset_filtered.map(lambda

example:{temp_text:unicodedata.normalize(NFKD,

f{example[title]}

{example[text]}).replace(,)},num_proc2)[temp_text]all_articles_indices

[]for

idxdf_chunk_size]articles_indices,

merged_top_scores

modified_texts)all_articles_indices.append(articles_indices)all_articles_values.append(merged_top_scores)article_indices_array

np.concatenate(all_articles_indices,

np.concatenate(all_articles_values,

axis0).reshape(-1)top_per_query

article_indices_array.shape[1]articles_flatten

[(articles_values_array[index],cohere_dataset_filtered[idx.item()][title],unicodedata.normalize(NFKD,

cohere_dataset_filtered[idx.item()][text]),)for

index,idx

enumerate(article_indices_array.reshape(-1))]retrieved_articles

top_per_query)return

modified_texts):corpus_df_valid

row:f{row[prompt]}\n{row[prompt]}\n{row[prompt]}\n{row[A]}\n{row[B]}\n{row[C]}\n{row[D]}\n{row[E]},axis1)#.values

###vectorizer1

TfidfVectorizer(ngram_range(1,2),#token_patternr(?u)\b[\w/.-]\b|!|/|\?|\|\,

###stop_wordsstop_words,sublinear_tfTrue)vectorizer1.fit(corpus_df_valid)vocab_df_valid

vectorizer1.get_feature_names()

###vectorizer

TfidfVectorizer(ngram_range(1,2),#token_patternr(?u)\b[\w/.-]\b|!|/|\?|\|\,

###stop_wordsstop_words,vocabularyvocab_df_valid,sublinear_tfTrue)vectorizer.fit(

cudf.Series(modified_texts[:500000])

###corpus_tf_idf

vectorizer.transform(corpus_df_valid)print(flength

vectorizer

{len(vectorizer.get_feature_names())})

###chunk_size

cudf.Series(modified_texts[idx:

idxchunk_size])

wiki_vectors.T).toarray()chunk_top_indices

temp_scores.argpartition(-top_per_chunk,

axis1)[:,

-top_per_chunk:]chunk_top_values

temp_scores[np.arange(temp_scores.shape[0])[:,

np.newaxis],

chunk_top_indices]all_chunk_top_indices.append(chunk_top_indices

idx)all_chunk_top_values.append(chunk_top_values)top_indices_array

np.concatenate(all_chunk_top_indices,

np.concatenate(all_chunk_top_values,

axis1)[:,-top_per_query:]merged_top_indices

top_values_array.argsort(axis1)[:,-top_per_query:]articles_indices

top_indices_array[np.arange(top_indices_array.shape[0])[:,

np.newaxis],

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/test.csv)

get_relevant_documents_parsed(df_valid)

get_relevant_documents(df_valid)

gc.collect()#

prepare_answering_input2(tokenizer,

question,

options,max_lengthmax_seq_length,paddinglongest,truncationFalse,return_tensorspt,)input_ids

tokenized_examples[input_ids].unsqueeze(0)attention_mask

tokenized_examples[attention_mask].unsqueeze(0)example_encoded

{input_ids:

input_ids.to(devices[gpu_id]),attention_mask:

attention_mask.to(devices[gpu_id]),}return

example_encoded#

https://www.kaggle.com/code/philippsinger/h2ogpt-perplexity-ranking

import

predictions[u].split()user_true

item

torch.device(cuda:1)model_paths

loss_results

AutoTokenizer.from_pretrained(model)model0

AutoModelForMultipleChoice.from_pretrained(model).to(device0)model1

AutoModelForMultipleChoice.from_pretrained(model).to(device1)models

[[],[]]submit_ids

df_valid.iloc[indexSKIP].valuessubmit_ids[gpu_id].append(columns[0])question

columns[1]options

retrieved_articles[indexSKIP][x][2]

for

retrieved_articles_parsed[indexSKIP][x][2]

for

prepare_answering_input2(tokenizertokenizer,

questionquestion,optionsoptions,

gpu_id)inputs2

prepare_answering_input2(tokenizertokenizer,

questionquestion,optionsoptions,

gpu_id)with

models[gpu_id](**inputs1)losses1

-outputs1.logits[0].detach().cpu().numpy()with

torch.no_grad():with

models[gpu_id](**inputs2)losses2

-outputs2.logits[0].detach().cpu().numpy()all_losses[gpu_id].append(

(losses1losses2)/2.

threading.Thread(targetinference_thread,

args(0,

threading.Thread(targetinference_thread,

args(1,

threadsthread1.start()thread2.start()#

Wait

finishthread1.join()thread2.join()print(Both

threads

np.concatenate(all_losses,axis0)loss_results.append(

all_losses

gc.collect()libc.malloc_trim(0)4.4.5

评测结果并保存

np.array(list(ABCDE))[predictions_as_ids]

predict

predictions_as_answer_letterspredictions

for

)pd.DataFrame({id:submit_ids,prediction:predictions}).to_csv(submission.csv,

indexFalse)plt.hist(

pd.read_csv(/kaggle/input/kaggle-llm-science-exam/train.csv,

MAP3

MAP_at_3(submission.prediction.values,

true.answer.values)