{ "cells": [ { "cell_type": "markdown", "id": "42574ed9-3ada-4b0e-a97d-a400bea9ce33", "metadata": {}, "source": [ "# 3.1 多序列分类任务" ] }, { "cell_type": "markdown", "id": "f819259d-7804-42d8-9539-fe9f2d45a225", "metadata": {}, "source": [ "前面的序列分类问题，一般都是单序列问题，但生物序列中，也存在大量的多序列分析预测任务。在自然语言任务中，其实也是类似的，如文本对的相似性判断任务等，也是多序列问题。\n", "\n", "**多序列交互预测**任务是生物信息学中的一个重要研究方向，主要目的是通过分析和建模多个生物序列之间的相互作用来理解生物过程和分子机制。常见的多序列类型包括 DNA、RNA 和蛋白质序列。以下是对该任务的简要介绍：\n", "\n", "---\n", "\n", "### **1. 多序列交互预测的定义**\n", "多序列交互预测任务旨在通过计算和算法方法，预测多个生物分子（如 DNA、RNA 和蛋白质）之间的物理或功能性相互作用。例如：\n", "- **蛋白质-蛋白质交互（PPI）**：预测两种或多种蛋白质是否会形成复合物或协同工作。\n", "- **RNA-蛋白质交互（RPI）**：预测 RNA 和蛋白质之间的结合位点或结合强度。\n", "- **DNA-蛋白质交互**：预测转录因子与 DNA 的结合位置和作用强度。\n", "\n", "---\n", "\n", "### **2. 任务的重要性**\n", "- **理解分子机制**：\n", " - 生物分子之间的相互作用是许多生物过程的基础，例如信号转导、转录调控和代谢。\n", "- **药物研发**：\n", " - 通过预测靶向蛋白质的相互作用，设计小分子药物或生物大分子药物。\n", "- **疾病研究**：\n", " - 某些疾病（如神经退行性疾病）与分子间异常交互有关，预测交互可揭示潜在机制。\n", "\n", "---\n", "\n", "### **3. 常见的多序列交互类型**\n", "\n", "#### **（1）蛋白质-蛋白质交互（Protein-Protein Interaction, PPI）**\n", "- **目标**：预测两种或多种蛋白质是否会形成复合物或相互作用。\n", "- **挑战**：\n", " - 蛋白质结构的高维复杂性。\n", " - 动态交互（不同条件下的交互行为）。\n", "- **应用**：\n", " - 生物通路建模。\n", " - 疾病相关蛋白预测。\n", "\n", "#### **（2）RNA-蛋白质交互（RNA-Protein Interaction, RPI）**\n", "- **目标**：预测 RNA 和蛋白质之间的结合位置、强度或调控作用。\n", "- **挑战**：\n", " - RNA 的二级结构和序列依赖性。\n", " - 蛋白质与 RNA 的结合位点特异性。\n", "- **应用**：\n", " - 非编码 RNA 功能研究。\n", " - 转录后调控机制。\n", "\n", "#### **（3）DNA-蛋白质交互（DNA-Protein Interaction, DPI）**\n", "- **目标**：预测 DNA 上的结合位点或转录因子与 DNA 的作用强度。\n", "- **挑战**：\n", " - 转录因子识别序列的特异性和冗余性。\n", " - 环境因素（如染色质结构）对结合的影响。\n", "- **应用**：\n", " - 基因调控网络构建。\n", " - 基因编辑靶点预测。\n", "\n", "#### **（4）其他交互**\n", "- DNA-RNA 交互。\n", "- 蛋白质-小分子交互。\n", "- 蛋白质-多肽交互。\n", "\n", "\n", "### **4. 数据集与基准**\n", "\n", "#### **（1）蛋白质-蛋白质交互**\n", "- **数据集**：\n", " - STRING：全面的蛋白质交互数据库。\n", " - BioGRID：实验验证的交互数据库。\n", "\n", "#### **（2）RNA-蛋白质交互**\n", "- **数据集**：\n", " - RPI369：RNA-蛋白质交互数据集。\n", " - NPInter：实验验证的 RNA-蛋白质交互。\n", "\n", "#### **（3）DNA-蛋白质交互**\n", "- **数据集**：\n", " - JASPAR：转录因子结合位点。\n", " - ChIP-seq 数据：从实验中获取 DNA-蛋白质交互信息。\n", "\n", "\n", "### **5. 课程数据集**\n", "\n", "本例程使用了相对简单的蛋白质编码数据集，也就是sentence1是DNA序列，sentence2是对应编码后的蛋白质序列。\n", "\n", "也就是我们一般中学就学过的三联密码子。\n", "每 3 个DNA核苷酸组成一个密码子，编码一个蛋白质氨基酸。\n", "共有 64 种密码子，其中 61 种编码氨基酸，3 种为终止密码子。\n", "\n", "数据集来自lucaone的论文。\n" ] }, { "cell_type": "code", "execution_count": 2, "id": "a1261f22-4754-47d1-b261-e6252334396f", "metadata": {}, "outputs": [], "source": [ "import subprocess\n", "import os\n", "\n", "result = subprocess.run('bash -c \"source /etc/network_turbo && env | grep proxy\"', shell=True, capture_output=True, text=True)\n", "output = result.stdout\n", "for line in output.splitlines():\n", " if '=' in line:\n", " var, value = line.split('=', 1)\n", " os.environ[var] = value\n", "\n", "\n", "# import os\n", "\n", "# # 设置环境变量\n", "# os.environ['HF_ENDPOINT'] = 'https://hf-mirror.com'\n", "\n", "# # 打印环境变量以确认设置成功\n", "# print(os.environ.get('HF_ENDPOINT'))" ] }, { "cell_type": "code", "execution_count": 8, "id": "75a1b6e6-6942-4c58-9fda-7d89dcf15a6a", "metadata": {}, "outputs": [], "source": [ "from datasets import load_dataset\n", "from transformers import AutoTokenizer, DataCollatorWithPadding\n", "from transformers import Trainer\n", "import evaluate\n", "import numpy as np\n", "from transformers import TrainingArguments\n", "from transformers import AutoModelForSequenceClassification\n", "\n", "\n", "# 假设你的JSON文件名为 'data.json' 并且每行是一个独立的JSON对象\n", "raw_datasets = load_dataset('dnagpt/gene_lan_transfer', 'dna_protein_pair')[\"train\"].train_test_split(test_size=0.1, shuffle=True) # 或者指定特定语言如 'zh' 表示中文,https://huggingface.co/datasets/google-research-datasets/paws-x\n", "\n", "#分词器\n", "tokenizer = AutoTokenizer.from_pretrained(\"dnagpt/gene_eng_gpt2_v0\")\n", "tokenizer.pad_token = tokenizer.eos_token\n", "\n", "# 修改分词器的填充方向为左侧，默认右侧，分类问题可以是左侧\n", "#tokenizer.padding_side = \"left\"\n" ] }, { "cell_type": "code", "execution_count": 9, "id": "c25ba244-344b-41b9-be2e-4676dbe4ba41", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "DatasetDict({\n", " train: Dataset({\n", " features: ['sentence1', 'sentence2', 'label'],\n", " num_rows: 3600\n", " })\n", " test: Dataset({\n", " features: ['sentence1', 'sentence2', 'label'],\n", " num_rows: 400\n", " })\n", "})" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "raw_datasets" ] }, { "cell_type": "code", "execution_count": 10, "id": "8f6d2dbf-5b38-48d2-ac2d-0c6f98f76540", "metadata": {}, "outputs": [ { "data": { "text/plain": [ "{'sentence1': 'ATGGACTTGCAGAATTATTCCTTTGTGTCAGAATTTATATTGCATGGACTCTGCAATTCACGGAATCTCCAAATGTTTTTCTTTGTATTCTTCTCTGGAATCTATTTAGCCATTGTGCTGGGTAACCTCCTCATTGTAGTCACTGTCATTTTTGACCCTCGCTTGCACTCTTCCCCTATGTACTTCCTGCTGGGGAACTTATCTTTCCTTGACATGTGGCTGGCTTCATTTGCCACACCCAAGATGATCAGGGATTTTCTTAGTGATCGAAAGCTTATCTCCTTTGGGGGATGCATGGCTCAAATCTTCTTCTTGCACTTTATTGGTGGGGCTGAGATGATACTGCTGGTTTCCATGGCCTATGACAGGTATGTGGCCATATGCAAACCCTTGCATTATATGACTGTGATGAATCGGAGGACTTGCATTGGGCTGGTGCTGATTTCATGGACTATAGGATTTGTGCACTCCATCAGTCAAGTAGCTTTCACTGTGAATTTACCTTACTGTGGCCCCAATGAGGTGGACAGCTTCTTTTGTGATCTCCCTTTGGTGATCAAACTTGCTTGCAGGGACACCTATGTCTTAGGCATACTTATGATCTCAGACAGTGGGTTGCTTTCTATGAGTTGTTTTCTGCTCCTCATGATCTCCTACACAGTTATCCTTGTCACTGTGCAACAGCATGCTGCTGGTGGCGTCTCCAAAGCACTATCTACTTGCTCTGCTCACATTATGGTTGTCACACTTTTCTTTGGGCCTTGCATATTCATTTATGTGTGGCCTTTCAGTAGGTTCTCTGTGGATAAGGTCTTGTCTGTGTTTTACACAATTTTTACTCCACTTCTGAATCCCCTAATCTACACGTTGAGAAATGAAGAGATGAAAGCAGCCATGAAGAAACTGTGGAACCGACACGTGACTTTTCAC',\n", " 'sentence2': 'MDLQNYSFVSEFILHGLCNSRNLQMFFFVFFSGIYLAIVLGNLLIVVTVIFDPRLHSSPMYFLLGNLSFLDMWLASFATPKMIRDFLSDRKLISFGGCMAQIFFLHFIGGAEMILLVSMAYDRYVAICKPLHYMTVMNRRTCIGLVLISWTIGFVHSISQVAFTVNLPYCGPNEVDSFFCDLPLVIKLACRDTYVLGILMISDSGLLSMSCFLLLMISYTVILVTVQQHAAGGVSKALSTCSAHIMVVTLFFGPCIFIYVWPFSRFSVDKVLSVFYTIFTPLLNPLIYTLRNEEMKAAMKKLWNRHVTFH',\n", " 'label': 1}" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "raw_datasets[\"train\"][0]" ] }, { "cell_type": "code", "execution_count": 12, "id": "d8bb90dd-b32a-418e-9e19-1bd617408cde", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "['ATGG', 'ACTTGC', 'AGAA', 'TTATTCC', 'TTTGTG', 'TCAGAA', 'TTTA', 'TATTGC', 'ATGGACTC', 'TGCAATTC', 'ACGG', 'AATCTCC', 'AAATGTTTT', 'TCTTTG', 'TATTCTTC', 'TCTGG', 'AATCTATT', 'TAGCC', 'ATTG', 'TGCTGGG', 'TAACCTCC', 'TCATTG', 'TAG', 'TCACTG', 'TCATTTTTG', 'ACCC', 'TCGC', 'TTGC', 'ACTC', 'TTCCCC', 'TATGTAC', 'TTCCTGC', 'TGGGGAAC', 'TTATC', 'TTTCCTTG', 'ACATG', 'TGGCTGGC', 'TTCATT', 'TGCC', 'ACACCC', 'AAG', 'ATGATC', 'AGGG', 'ATTTTC', 'TTAGTG', 'ATCGAA', 'AGC', 'TTATC', 'TCCTTTG', 'GGGG', 'ATGC', 'ATGGC', 'TCAAATC', 'TTCTTC', 'TTGC', 'ACTT', 'TATTGG', 'TGGGGC', 'TGAGATG', 'ATAC', 'TGCTGG', 'TTTCC', 'ATGGCC', 'TATG', 'ACAGG', 'TATG', 'TGGCC', 'ATATGCAA', 'ACCCTTGC', 'ATTATA', 'TGAC', 'TGTGATG', 'AATC', 'GGAGG', 'ACTTGC', 'ATTGGGC', 'TGGTGC', 'TGATT', 'TCATGG', 'ACTATAGG', 'ATTTGTGC', 'ACTCCATC', 'AGTC', 'AAGTAGC', 'TTTC', 'ACTGTG', 'AATTTACC', 'TTACTG', 'TGGCCCC', 'AATG', 'AGGTGG', 'ACAGC', 'TTCTTTTG', 'TGATC', 'TCCC', 'TTTGG', 'TGATC', 'AAAC', 'TTGCTTGC', 'AGGGACACC', 'TATG', 'TCTTAGGC', 'ATAC', 'TTATG', 'ATCTCAG', 'ACAGTGGG', 'TTGCTTTC', 'TATG', 'AGTTG', 'TTTTC', 'TGCTCC', 'TCATG', 'ATCTCC', 'TACACAG', 'TTATCC', 'TTG', 'TCACTG', 'TGCAAC', 'AGCATGC', 'TGCTGG', 'TGGCG', 'TCTCC', 'AAAGC', 'ACTATC', 'TACTTGC', 'TCTGC', 'TCACATT', 'ATGGTTG', 'TCACAC', 'TTTTCTTTG', 'GGCC', 'TTGC', 'ATATTCATT', 'TATGTG', 'TGGCCTTTC', 'AGTAGG', 'TTCTCTG', 'TGG', 'ATAAGG', 'TCTTG', 'TCTGTG', 'TTTTACAC', 'AATTTT', 'TACTCC', 'ACTTC', 'TGAA', 'TCCCC', 'TAA', 'TCTAC', 'ACGTTG', 'AGAA', 'ATGAAG', 'AGATG', 'AAAGC', 'AGCCATG', 'AAGAA', 'ACTGTGG', 'AACCG', 'ACACG', 'TGACTTTTC', 'AC', 'M', 'DLQ', 'N', 'Y', 'SFV', 'SEF', 'IL', 'HGL', 'CN', 'SR', 'NL', 'QM', 'FF', 'FVFF', 'SGI', 'YLAI', 'VLG', 'N', 'LLI', 'VV', 'TVI', 'FDP', 'RLH', 'SS', 'PM', 'YF', 'LLG', 'NL', 'SFL', 'DM', 'WL', 'ASF', 'ATP', 'KMI', 'RDFL', 'SD', 'RKLI', 'SF', 'GGC', 'MAQ', 'IF', 'FLH', 'FIGG', 'AEMI', 'LLV', 'SM', 'AYDR', 'YVAI', 'CK', 'PL', 'HYM', 'TVM', 'N', 'RR', 'TC', 'IGL', 'VLI', 'SW', 'TIG', 'FVH', 'SI', 'SQV', 'AFTV', 'NL', 'PY', 'CGP', 'NE', 'VD', 'SF', 'FC', 'DLPL', 'VI', 'KL', 'ACRD', 'TY', 'VLGIL', 'MISD', 'SGLL', 'SM', 'SCF', 'LLL', 'MI', 'SYTV', 'ILV', 'TV', 'QQH', 'AAGGV', 'SKAL', 'STC', 'SAH', 'IM', 'VV', 'TLF', 'FGP', 'CI', 'FI', 'YVW', 'PF', 'SRF', 'SVDK', 'VLSV', 'FY', 'TIF', 'TPLL', 'N', 'PLIY', 'TLR', 'N', 'EE', 'MKAA', 'MK', 'KLW', 'N', 'RHV', 'TFH']\n" ] } ], "source": [ "print(tokenizer.tokenize(raw_datasets[\"train\"][0][\"sentence1\"], raw_datasets[\"train\"][0][\"sentence2\"]))" ] }, { "cell_type": "code", "execution_count": 13, "id": "c314d87b-8e71-4516-997a-eb527fbea5f1", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "dna datasets mean token lenght 242.49 min token length 44 max token length 466\n" ] } ], "source": [ "token_len_list = []\n", "for item in raw_datasets[\"test\"]:\n", " inputs = tokenizer.tokenize(item[\"sentence1\"], item[\"sentence2\"])\n", " token_len_list.append( len(inputs) )\n", "\n", "mean_len = sum(token_len_list)/len(token_len_list)\n", "min_len = min(token_len_list)\n", "max_len = max(token_len_list)\n", "\n", "print(\"dna datasets \", \"mean token lenght\", mean_len, \"min token length\", min_len, \"max token length\", max_len)" ] }, { "cell_type": "code", "execution_count": 14, "id": "10e7e7d0-1f97-4cae-ba4b-7af3332e13d4", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "#统计图\n", "import matplotlib.pyplot as plt\n", "import seaborn as sns\n", "import numpy as np\n", "\n", "# 假设这是您的 token_len_list\n", "\n", "# 设置画布大小\n", "plt.figure(figsize=(10, 6))\n", "\n", "# 使用 seaborn 生成直方图\n", "sns.histplot(token_len_list, bins=30, kde=False, color=\"skyblue\", edgecolor=\"black\")\n", "\n", "# 添加标题和标签\n", "plt.title(\"Distribution of Token Lengths\")\n", "plt.xlabel(\"Token Length\")\n", "plt.ylabel(\"Frequency\")\n", "\n", "# 显示平均值线\n", "mean_value = np.mean(token_len_list)\n", "plt.axvline(mean_value, color='red', linestyle='dashed', linewidth=2)\n", "plt.text(mean_value + 2, plt.ylim()[1]*0.9, f'Mean: {mean_value:.2f}', color='red')\n", "\n", "# 显示中位数线\n", "median_value = np.median(token_len_list)\n", "plt.axvline(median_value, color='green', linestyle='dashed', linewidth=2)\n", "plt.text(median_value - 10, plt.ylim()[1]*0.8, f'Median: {median_value:.2f}', color='green')\n", "\n", "# 显示图形\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": 17, "id": "a82bd638-9277-4321-8ca1-92816679ee5f", "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { "model_id": "1cc3314350ac4e28aade87a47b706afc", "version_major": 2, "version_minor": 0 }, "text/plain": [ "Map: 0%| | 0/3600 [00:00, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::logic_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::locale::~locale()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::basic_string(std::string const&, unsigned long, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_end_catch@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_ofstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::logic_error::~logic_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for __cxxabiv1::__si_class_type_info@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ios >::_M_cache_locale(std::locale const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_stringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `operator new[](unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::_M_leak_hard()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ifstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_streambuf >::basic_streambuf(std::basic_streambuf > const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::append(char const*, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::basic_string(std::string const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned short@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::resize(unsigned long, char)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for char const*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ctype::_M_widen_init() const@GLIBCXX_3.4.11'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_invalid_argument(char const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::locale::operator=(std::locale const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ios >::_M_cache_locale(std::locale const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_decrement(std::_Rb_tree_node_base const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_free_exception@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::condition_variable::notify_one()@GLIBCXX_3.4.11'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ios_base::Init::~Init()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::~basic_string()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_pure_virtual@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream::flush()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for __cxxabiv1::__class_type_info@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_rethrow@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_stringbuf, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_fstream >::~basic_fstream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::compare(char const*) const@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_ostringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::locale::locale()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::chrono::_V2::system_clock::now()@GLIBCXX_3.4.19'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_ifstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Hash_bytes(void const*, unsigned long, unsigned long)@CXXABI_1.3.5'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(long long)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for char*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__detail::_Prime_rehash_policy::_M_need_rehash(unsigned long, unsigned long, unsigned long) const@GLIBCXX_3.4.18'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::out_of_range@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(unsigned long)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_increment(std::_Rb_tree_node_base const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ios_base::~ios_base()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::range_error::~range_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__basic_file::~__basic_file()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_guard_acquire@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(bool)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::overflow_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_fstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::range_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ios >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_filebuf >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `operator delete[](void*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_stringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::basic_string(unsigned long, char, std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__detail::_List_node_base::_M_transfer(std::__detail::_List_node_base*, std::__detail::_List_node_base*)@GLIBCXX_3.4.15'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::replace(unsigned long, unsigned long, char const*, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for std::exception@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::_Rep::_M_destroy(std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::istream& std::istream::_M_extract(double&)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_filebuf >::close()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_fstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ifstream >::basic_ifstream(char const*, std::_Ios_Openmode)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::append(std::string const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `operator new(unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_istringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned int@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::append(char const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::domain_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::find(char, unsigned long) const@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream::put(char)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for int@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_bad_alloc()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_thread_atexit@CXXABI_1.3.7'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_increment(std::_Rb_tree_node_base*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ifstream >::~basic_ifstream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ios_base::Init::Init()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::condition_variable::condition_variable()@GLIBCXX_3.4.11'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_filebuf >::basic_filebuf()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_istringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::domain_error::~domain_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::cerr@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::find(char const*, unsigned long, unsigned long) const@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_istringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::basic_string(std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_stringbuf, std::allocator >::str() const@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::invalid_argument@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for void*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::assign(std::string const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ostringstream, std::allocator >::~basic_ostringstream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_rebalance_for_erase(std::_Rb_tree_node_base*, std::_Rb_tree_node_base&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned long@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__detail::_List_node_base::_M_hook(std::__detail::_List_node_base*)@GLIBCXX_3.4.15'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__detail::_List_node_base::_M_unhook()@GLIBCXX_3.4.15'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ostringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_stringbuf, std::allocator >::_M_sync(char*, unsigned long, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_iostream >::~basic_iostream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::locale::locale(std::locale const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_istringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `log2f@GLIBC_2.2.5'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream::operator<<(std::basic_streambuf >*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_streambuf >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::exception::~exception()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::_Rep::_S_create(unsigned long, unsigned long, std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__basic_file::is_open() const@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_istringstream, std::allocator >::~basic_istringstream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::swap(std::string&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned long*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ostringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_streambuf >::basic_streambuf(std::basic_streambuf > const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ios >::init(std::basic_streambuf >*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_bad_cast()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ios >::clear(std::_Ios_Iostate)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_streambuf >::operator=(std::basic_streambuf > const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `operator delete(void*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream::operator<<(int)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::_Rep::_S_empty_rep_storage@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::_Rep::_M_destroy(std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_iostream >::~basic_iostream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::runtime_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ofstream >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_insert_and_rebalance(bool, std::_Rb_tree_node_base*, std::_Rb_tree_node_base*, std::_Rb_tree_node_base&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_stringstream, std::allocator >::~basic_stringstream()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `VTT for std::basic_stringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(long)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::istream::get()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned long long@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ostream >& std::operator<< >(std::basic_ostream >&, char const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::out_of_range::~out_of_range()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::length_error::~length_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ostream >& std::__ostream_insert >(std::basic_ostream >&, char const*, long)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::invalid_argument::~invalid_argument()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::swap(std::basic_string, std::allocator >&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::cout@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(unsigned long long)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for int*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(void const*)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::underflow_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_streambuf >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for std::out_of_range@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_allocate_exception@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_ios >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for void const*@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ios >::init(std::basic_streambuf >*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::reserve(unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_begin_catch@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for long@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::_Rep::_S_empty_rep_storage@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::_M_leak()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_filebuf >::open(char const*, std::_Ios_Openmode)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_stringbuf, std::allocator >::_M_sync(wchar_t*, unsigned long, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::istream::getline(char*, long, char)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_istream >& std::getline, std::allocator >(std::basic_istream >&, std::basic_string, std::allocator >&, char)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_stringstream, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::condition_variable::~condition_variable()@GLIBCXX_3.4.11'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::basic_stringbuf, std::allocator >@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::insert(unsigned long, char const*, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::string::assign(char const*, unsigned long)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for unsigned char@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ios_base::ios_base()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_out_of_range(char const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::overflow_error::~overflow_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_length_error(char const*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::__throw_system_error(int)@GLIBCXX_3.4.11'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ofstream >::close()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::ostream& std::ostream::_M_insert(double)@GLIBCXX_3.4.9'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_streambuf >::operator=(std::basic_streambuf > const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `typeinfo for long long@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_string, std::allocator >::basic_string(char const*, unsigned long, std::allocator const&)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_ifstream >::close()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_guard_release@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `__cxa_throw@CXXABI_1.3'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::underflow_error::~underflow_error()@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::_Rb_tree_decrement(std::_Rb_tree_node_base*)@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `vtable for std::length_error@GLIBCXX_3.4'\n", "/root/miniconda3/compiler_compat/ld: /usr/local/cuda/lib64/libcufile.so: undefined reference to `std::basic_filebuf >::~basic_filebuf()@GLIBCXX_3.4'\n", "collect2: error: ld returned 1 exit status\n" ] } ], "source": [ "#指标函数定义\n", "def compute_metrics(eval_pred):\n", " predictions, labels = eval_pred\n", " predictions = np.argmax(predictions, axis=1)\n", " return {'accuracy': (predictions==labels).sum() / len(labels)}\n", "\n", "\n", "training_args = TrainingArguments(\n", " output_dir=\"ds_job_multi\",\n", " learning_rate=1e-5,\n", " lr_scheduler_type=\"constant_with_warmup\",\n", " warmup_ratio=0.1,\n", " optim='adamw_torch',\n", " weight_decay=0.0,\n", " per_device_train_batch_size=20,\n", " per_device_eval_batch_size=20,\n", " num_train_epochs=8, #训练多少轮\n", " evaluation_strategy=\"epoch\",\n", " save_strategy=\"epoch\",\n", " logging_strategy=\"epoch\",\n", " load_best_model_at_end=True\n", ")\n", "\n", "trainer = Trainer(\n", " model,\n", " training_args,\n", " train_dataset=tokenized_datasets[\"train\"],\n", " eval_dataset=tokenized_datasets[\"test\"],\n", " data_collator=data_collator,\n", " tokenizer=tokenizer,\n", " compute_metrics=compute_metrics,\n", ")" ] }, { "cell_type": "code", "execution_count": 21, "id": "74f7207c-116d-4621-b795-57df71a33d13", "metadata": {}, "outputs": [ { "data": { "text/html": [ "\n", "
\n", " \n", " \n", " [1440/1440 08:28, Epoch 8/8]\n", "
\n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", " \n", "
EpochTraining LossValidation LossAccuracy
10.6894000.5688640.752500
20.5070000.5482190.772500
30.4215000.5908790.775000
40.3015000.4945720.817500
50.1907000.3814230.857500
60.1465000.7062050.875000
70.0841000.9037860.865000
80.0731000.7496690.885000

" ], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "TrainOutput(global_step=1440, training_loss=0.3017331454488966, metrics={'train_runtime': 509.1802, 'train_samples_per_second': 56.562, 'train_steps_per_second': 2.828, 'total_flos': 7525346417049600.0, 'train_loss': 0.3017331454488966, 'epoch': 8.0})" ] }, "execution_count": 21, "metadata": {}, "output_type": "execute_result" } ], "source": [ "trainer.train() #模型训练" ] }, { "cell_type": "code", "execution_count": 22, "id": "639085a2-b271-4147-8e4b-2c01662410ac", "metadata": {}, "outputs": [ { "data": { "text/html": [], "text/plain": [ "" ] }, "metadata": {}, "output_type": "display_data" }, { "data": { "text/plain": [ "{'accuracy': 0.8575, 'f1': 0.8503937007874016}" ] }, "execution_count": 22, "metadata": {}, "output_type": "execute_result" } ], "source": [ "#模型测试\n", "import evaluate\n", "predictions = trainer.predict(tokenized_datasets[\"test\"])\n", "preds = np.argmax(predictions.predictions, axis=-1)\n", "metric = evaluate.load(\"glue\", \"mrpc\")\n", "ret = metric.compute(predictions=preds, references=predictions.label_ids)\n", "ret" ] }, { "cell_type": "code", "execution_count": 23, "id": "68ed8a02-8af3-433e-bdbd-26020582b904", "metadata": {}, "outputs": [ { "data": { "image/png": "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", "text/plain": [ "

" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay\n", "import matplotlib.pyplot as plt\n", "\n", "# 假设 predictions.label_ids 是真实的标签，preds 是模型的预测\n", "cm = confusion_matrix(predictions.label_ids, preds)\n", "\n", "# 可视化混淆矩阵\n", "disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=['Class 0', 'Class 1'])\n", "disp.plot(cmap=plt.cm.Blues)\n", "plt.title('Confusion Matrix')\n", "plt.show()" ] }, { "cell_type": "code", "execution_count": null, "id": "6da47db7-230c-4e1f-8275-b4b464b82be5", "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, "language_info": { "codemirror_mode": { "name": "ipython", "version": 3 }, "file_extension": ".py", "mimetype": "text/x-python", "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", "version": "3.12.3" } }, "nbformat": 4, "nbformat_minor": 5 }