diff --git a/FScanpy_Demo.ipynb b/FScanpy_Demo.ipynb index 73ddc30..2284269 100644 --- a/FScanpy_Demo.ipynb +++ b/FScanpy_Demo.ipynb @@ -23,7 +23,7 @@ ] }, { - "cell_type": "raw", + "cell_type": "markdown", "metadata": { "vscode": { "languageId": "raw" @@ -109,19 +109,81 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 5, "metadata": {}, "outputs": [ { - "ename": "ImportError", - "evalue": "cannot import name 'PRFPredictor' from 'FScanpy' (unknown location)", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mImportError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[3], line 6\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mmatplotlib\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mpyplot\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m \u001b[38;5;21;01mplt\u001b[39;00m\n\u001b[1;32m 5\u001b[0m \u001b[38;5;66;03m# Import FScanpy related modules\u001b[39;00m\n\u001b[0;32m----> 6\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mFScanpy\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m PRFPredictor, predict_prf, plot_prf_prediction\n\u001b[1;32m 7\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mFScanpy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mdata\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m get_test_data_path, list_test_data\n\u001b[1;32m 8\u001b[0m \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01mFScanpy\u001b[39;00m\u001b[38;5;21;01m.\u001b[39;00m\u001b[38;5;21;01mutils\u001b[39;00m \u001b[38;5;28;01mimport\u001b[39;00m fscanr, extract_prf_regions\n", - "\u001b[0;31mImportError\u001b[0m: cannot import name 'PRFPredictor' from 'FScanpy' (unknown location)" + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-08-14 15:54:26.764777: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2025-08-14 15:54:26.765259: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-08-14 15:54:26.818561: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/attr_value.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/resource_handle.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor_shape.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/types.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/full_type.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/function.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/node_def.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/op_def.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/graph.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/graph_debug_info.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/versions.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/config.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at xla/tsl/protobuf/coordination_config.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/cost_graph.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/step_stats.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/allocation_description.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor_description.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/cluster.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/debug.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "2025-08-14 15:54:28.305921: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-08-14 15:54:28.307332: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n" ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "✅ Environment setup complete!\n", + "📋 Available test data:\n" + ] + }, + { + "data": { + "text/plain": [ + "['blastx_example.xlsx',\n", + " 'full_seq.xlsx',\n", + " 'mrna_example.fasta',\n", + " 'region_example.csv']" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" } ], "source": [ @@ -150,24 +212,24 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "📁 数据文件路径:\n", - " BLASTX数据: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/blastx_example.xlsx\n", - " mRNA序列: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/mrna_example.fasta\n", - " 验证区域: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/region_example.csv\n", + "📁 Data file paths:\n", + " BLASTX data: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/blastx_example.xlsx\n", + " mRNA sequences: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/mrna_example.fasta\n", + " Validation regions: /mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/data/test_data/region_example.csv\n", "\n", - "🧬 BLASTX数据概览:\n", - " 数据形状: (1000, 14)\n", - " 列名: ['DNA_seqid', 'Pep_seqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore', 'qframe', 'sframe']\n", - " 唯一序列数: 704\n", + "🧬 BLASTX data overview:\n", + " Data shape: (1000, 14)\n", + " Column names: ['DNA_seqid', 'Pep_seqid', 'pident', 'length', 'mismatch', 'gapopen', 'qstart', 'qend', 'sstart', 'send', 'evalue', 'bitscore', 'qframe', 'sframe']\n", + " Unique sequences: 704\n", "\n", - "📊 BLASTX数据示例:\n", + "📊 BLASTX data examples:\n", " DNA_seqid Pep_seqid pident length evalue qframe\n", "0 MSTRG.9998.1 CAMPEP_0196994412 68.27 104 1.000000e-33 2\n", "1 MSTRG.9996.1 CAMPEP_0197017426 49.16 297 3.000000e-79 2\n", @@ -203,30 +265,30 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🎯 验证区域数据概览:\n", - " 数据形状: (3, 8)\n", - " 列名: ['FS_period', '399bp', 'fs_position', 'DNA_seqid', 'label', 'source', 'FS_type', 'dataset']\n", - " 数据来源: {'EUPLOTES': 3}\n", + "🎯 Validation region data overview:\n", + " Data shape: (3, 8)\n", + " Column names: ['FS_period', '399bp', 'fs_position', 'DNA_seqid', 'label', 'source', 'FS_type', 'dataset']\n", + " Data sources: {'EUPLOTES': 3}\n", "\n", - "📋 验证区域数据示例:\n", + "📋 Validation region data examples:\n", " fs_position DNA_seqid label source FS_type\n", "0 16.0 MSTRG.18491.1 0 EUPLOTES negative\n", "1 16.0 MSTRG.4662.1 0 EUPLOTES negative\n", "2 16.0 MSTRG.14742.1 0 EUPLOTES negative\n", "\n", - "📈 标签分布:\n", + "📈 Label distribution:\n", "label\n", "0 3\n", "Name: count, dtype: int64\n", "\n", - "🔬 FS类型分布:\n", + "🔬 FS type distribution:\n", "FS_type\n", "negative 3\n", "Name: count, dtype: int64\n" @@ -263,39 +325,39 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🔍 运行FScanR分析...\n", - "参数设置: mismatch_cutoff=10, evalue_cutoff=1e-5, frameDist_cutoff=10\n", + "🔍 Running FScanR analysis...\n", + "Parameter settings: mismatch_cutoff=10, evalue_cutoff=1e-5, frameDist_cutoff=10\n", "\n", - "✅ FScanR分析完成！\n", - "检测到的潜在PRF位点数量: 24\n", + "✅ FScanR analysis complete!\n", + "Number of potential PRF sites detected: 16\n", "\n", - "📊 FScanR结果概览:\n", - " 列名: ['DNA_seqid', 'FS_start', 'FS_end', 'Pep_seqid', 'Pep_FS_start', 'Pep_FS_end', 'FS_type', 'Strand']\n", - " 涉及的序列数: 16\n", - " 链方向分布: {'+': 16, '-': 8}\n", - " FS类型分布: {1: 16, -1: 7, -2: 1}\n", + "📊 FScanR results overview:\n", + " Column names: ['DNA_seqid', 'FS_start', 'FS_end', 'Pep_seqid', 'Pep_FS_start', 'Pep_FS_end', 'FS_type', 'Strand']\n", + " Number of sequences involved: 12\n", + " Strand orientation distribution: {'+': 11, '-': 5}\n", + " FS type distribution: {1: 9, -1: 7}\n", "\n", - "🎯 FScanR结果示例:\n", + "🎯 FScanR results examples:\n", " DNA_seqid FS_start FS_end Pep_seqid Pep_FS_start \\\n", "0 MSTRG.9380.1 3797 3802 CAMPEP_0197017206 1137 \n", - "1 MSTRG.9431.1 4136 4192 CAMPEP_0197016790 657 \n", - "3 MSTRG.9432.1 848 904 CAMPEP_0197016790 753 \n", - "4 MSTRG.9582.1 302 304 CAMPEP_0197003180 214 \n", - "5 MSTRG.961.1 1536 1533 CAMPEP_0197017908 590 \n", + "1 MSTRG.9582.1 302 304 CAMPEP_0197003180 214 \n", + "2 MSTRG.961.1 1536 1533 CAMPEP_0197017908 590 \n", + "3 MSTRG.9622.1 555 560 CAMPEP_0197016962 182 \n", + "4 MSTRG.9648.1 801 803 CAMPEP_0197001104 257 \n", "\n", " Pep_FS_end FS_type Strand \n", "0 1138 1 + \n", - "1 675 1 + \n", - "3 2 1 - \n", - "4 214 1 + \n", - "5 19 -1 - \n" + "1 214 1 + \n", + "2 19 -1 - \n", + "3 183 1 + \n", + "4 257 1 + \n" ] } ], @@ -338,40 +400,40 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "📝 从mRNA序列中提取PRF位点周围序列...\n", + "📝 Extracting sequences around PRF sites from mRNA sequences...\n", "\n", - "✅ 序列提取完成！\n", - "成功提取的序列数量: 24\n", + "✅ Sequence extraction complete!\n", + "Number of successfully extracted sequences: 16\n", "\n", - "📏 序列长度验证:\n", - " 399bp序列长度分布: {399: 24}\n", - " 平均长度: 399.0\n", + "📏 Sequence length validation:\n", + " 399bp sequence length distribution: {399: 16}\n", + " Average length: 399.0\n", "\n", - "🧬 提取序列示例:\n", - "序列 1: MSTRG.9380.1\n", - " FS位置: 3797-3802\n", - " 链方向: +\n", - " FS类型: 1\n", - " 序列片段: AAGGAGTTTGAAGAAGAACAGGAAAAACAAGAGAAAGAGAGAAAGGAGAA...NNNNNNNNNNNNNNNNNNNN\n", + "🧬 Extracted sequence examples:\n", + "Sequence 1: MSTRG.9380.1\n", + " FS position: 3797-3802\n", + " Strand orientation: +\n", + " FS type: 1\n", + " Sequence fragment: AAGGAGTTTGAAGAAGAACAGGAAAAACAAGAGAAAGAGAGAAAGGAGAA...NNNNNNNNNNNNNNNNNNNN\n", "\n", - "序列 2: MSTRG.9431.1\n", - " FS位置: 4136-4192\n", - " 链方向: +\n", - " FS类型: 1\n", - " 序列片段: CAAGTATCTGAGTGGGAGGGAGACACAGGTGTTGATCAAACCCCATTCCC...ATAATGACGGAGGCTTCAGA\n", + "Sequence 2: MSTRG.9582.1\n", + " FS position: 302-304\n", + " Strand orientation: +\n", + " FS type: 1\n", + " Sequence fragment: ATCAAGCTGATTAGAGATGGAGGGGGAGGTGTGTTCAATAATATATCTAC...AGTCAACTTCCAGTCCAACA\n", "\n", - "序列 3: MSTRG.9432.1\n", - " FS位置: 848-904\n", - " 链方向: -\n", - " FS类型: 1\n", - " 序列片段: AGAAAGGATGGTACTGAAAATCAACGAAGTACTTTCACATTTTAGAAAGA...GCTGAGAACGATATTGACAA\n", + "Sequence 3: MSTRG.961.1\n", + " FS position: 1536-1533\n", + " Strand orientation: -\n", + " FS type: -1\n", + " Sequence fragment: ATGCTACTTTGGGAGAGAAAATTAACTGGGGAGAACTTGCATATGATTCT...ACAAATATTTCTCTAATTCA\n", "\n" ] } @@ -421,31 +483,45 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 10, "metadata": {}, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/predictor.py:23: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator _BinMapper from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator HistGradientBoostingClassifier from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n" + ] + }, { "name": "stdout", "output_type": "stream", "text": [ - "🤖 FScanpy预测器初始化完成\n", + "🤖 FScanpy predictor initialization complete\n", "\n", - "🎯 对 24 个FScanR识别的序列进行预测...\n", + "🎯 Predicting 16 sequences identified by FScanR...\n", "\n", - "📊 FScanR+FScanpy预测结果:\n", + "📊 FScanR+FScanpy prediction results:\n", " DNA_seqid FS_start FS_type Short_Probability Long_Probability \\\n", "0 MSTRG.9380.1 3797 1 0.239192 0.087024 \n", - "1 MSTRG.9431.1 4136 1 0.326807 0.356356 \n", - "2 MSTRG.9432.1 848 1 0.310908 0.159746 \n", - "3 MSTRG.9582.1 302 1 0.272451 0.223354 \n", - "4 MSTRG.961.1 1536 -1 0.263269 0.046773 \n", + "1 MSTRG.9582.1 302 1 0.272451 0.223354 \n", + "2 MSTRG.961.1 1536 -1 0.263269 0.046773 \n", + "3 MSTRG.9622.1 555 1 0.652591 0.408316 \n", + "4 MSTRG.9648.1 801 1 0.287211 0.308532 \n", "\n", " Ensemble_Probability \n", "0 0.147891 \n", - "1 0.344536 \n", - "2 0.220211 \n", - "3 0.242993 \n", - "4 0.133372 \n" + "1 0.242993 \n", + "2 0.133372 \n", + "3 0.506026 \n", + "4 0.300004 \n" ] } ], @@ -476,7 +552,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 11, "metadata": {}, "outputs": [ { @@ -484,9 +560,27 @@ "output_type": "stream", "text": [ "\n", - "🧪 对 3 个验证区域进行预测...\n", + "🧪 Predicting 3 validation regions...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator _BinMapper from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator HistGradientBoostingClassifier from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ "\n", - "📊 验证区域预测结果:\n", + "📊 Validation region prediction results:\n", " DNA_seqid label source Short_Probability Long_Probability \\\n", "0 MSTRG.18491.1 0 EUPLOTES 0.368610 0.144442 \n", "1 MSTRG.4662.1 0 EUPLOTES 0.229811 0.053352 \n", @@ -524,91 +618,39 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "🧬 选择演示序列: MSTRG.9127.1\n", - "序列长度: 256 bp\n", - "序列前100bp: TGGCCTTCTTACTTGGAAGTCCCCAAGGATCATCTTGGCCATCCTTGCTTTCTTCATGGCTAGATTCTACCTCCTCCCATAATTGTGTGAAACAAGTAAC...\n", + "🧬 Selected demonstration sequence: MSTRG.9127.1\n", + "Sequence length: 256 bp\n", + "First 100bp of sequence: TGGCCTTCTTACTTGGAAGTCCCCAAGGATCATCTTGGCCATCCTTGCTTTCTTCATGGCTAGATTCTACCTCCTCCCATAATTGTGTGAAACAAGTAAC...\n", "\n", - "🎯 使用plot_prf_prediction进行序列预测和可视化...\n" + "🎯 Using plot_prf_prediction for sequence prediction and visualization...\n" ] }, { "name": "stderr", "output_type": "stream", "text": [ - "/mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/predictor.py:335: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", - " plt.tight_layout()\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 39044 (\\N{CJK UNIFIED IDEOGRAPH-9884}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 27979 (\\N{CJK UNIFIED IDEOGRAPH-6D4B}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 27010 (\\N{CJK UNIFIED IDEOGRAPH-6982}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 29575 (\\N{CJK UNIFIED IDEOGRAPH-7387}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 28909 (\\N{CJK UNIFIED IDEOGRAPH-70ED}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 22270 (\\N{CJK UNIFIED IDEOGRAPH-56FE}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 31227 (\\N{CJK UNIFIED IDEOGRAPH-79FB}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 30721 (\\N{CJK UNIFIED IDEOGRAPH-7801}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 20998 (\\N{CJK UNIFIED IDEOGRAPH-5206}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 24067 (\\N{CJK UNIFIED IDEOGRAPH-5E03}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 38598 (\\N{CJK UNIFIED IDEOGRAPH-96C6}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 25104 (\\N{CJK UNIFIED IDEOGRAPH-6210}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 26435 (\\N{CJK UNIFIED IDEOGRAPH-6743}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 37325 (\\N{CJK UNIFIED IDEOGRAPH-91CD}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 24207 (\\N{CJK UNIFIED IDEOGRAPH-5E8F}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 21015 (\\N{CJK UNIFIED IDEOGRAPH-5217}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 20301 (\\N{CJK UNIFIED IDEOGRAPH-4F4D}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 32622 (\\N{CJK UNIFIED IDEOGRAPH-7F6E}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 36807 (\\N{CJK UNIFIED IDEOGRAPH-8FC7}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 28388 (\\N{CJK UNIFIED IDEOGRAPH-6EE4}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 38408 (\\N{CJK UNIFIED IDEOGRAPH-9608}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 20540 (\\N{CJK UNIFIED IDEOGRAPH-503C}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 30340 (\\N{CJK UNIFIED IDEOGRAPH-7684}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 32467 (\\N{CJK UNIFIED IDEOGRAPH-7ED3}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 26524 (\\N{CJK UNIFIED IDEOGRAPH-679C}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 65288 (\\N{FULLWIDTH LEFT PARENTHESIS}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 26465 (\\N{CJK UNIFIED IDEOGRAPH-6761}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 24418 (\\N{CJK UNIFIED IDEOGRAPH-5F62}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n", - "/home/guest01/.conda/envs/tf200/lib/python3.9/site-packages/IPython/core/pylabtools.py:152: UserWarning: Glyph 65289 (\\N{FULLWIDTH RIGHT PARENTHESIS}) missing from font(s) Liberation Sans.\n", - " fig.canvas.print_figure(bytes_io, **kw)\n" + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator _BinMapper from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator HistGradientBoostingClassifier from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", + " warnings.warn(\n", + "/mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/predictor.py:347: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -619,11 +661,11 @@ "output_type": "stream", "text": [ "\n", - "📊 序列预测结果统计:\n", - " 预测位点总数: 85\n", - " 高概率位点 (>0.8): 0\n", - " 中概率位点 (0.4-0.8): 6\n", - " 最高预测概率: 0.475\n" + "📊 Sequence prediction result statistics:\n", + " Total predicted sites: 85\n", + " High probability sites (>0.8): 0\n", + " Medium probability sites (0.4-0.8): 6\n", + " Highest prediction probability: 0.475\n" ] } ], @@ -664,7 +706,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 13, "metadata": {}, "outputs": [ { @@ -672,35 +714,35 @@ "output_type": "stream", "text": [ "\n", - "🔝 Top 5 预测位点:\n", - " 1. 位置 96: \n", - " - Short概率: 0.288\n", - " - Long概率: 0.755\n", - " - 集成概率: 0.475\n", - " - 密码子: TAA\n", - " 2. 位置 12: \n", - " - Short概率: 0.606\n", - " - Long概率: 0.177\n", - " - 集成概率: 0.434\n", - " - 密码子: TTG\n", - " 3. 位置 15: \n", - " - Short概率: 0.493\n", - " - Long概率: 0.329\n", - " - 集成概率: 0.428\n", - " - 密码子: GAA\n", - " 4. 位置 18: \n", - " - Short概率: 0.369\n", - " - Long概率: 0.510\n", - " - 集成概率: 0.426\n", - " - 密码子: GTC\n", - " 5. 位置 105: \n", - " - Short概率: 0.248\n", - " - Long概率: 0.671\n", - " - 集成概率: 0.418\n", - " - 密码子: ACT\n", + "🔝 Top 5 predicted sites:\n", + " 1. Position 96: \n", + " - Short probability: 0.288\n", + " - Long probability: 0.755\n", + " - Ensemble probability: 0.475\n", + " - Codon: TAA\n", + " 2. Position 12: \n", + " - Short probability: 0.606\n", + " - Long probability: 0.177\n", + " - Ensemble probability: 0.434\n", + " - Codon: TTG\n", + " 3. Position 15: \n", + " - Short probability: 0.493\n", + " - Long probability: 0.329\n", + " - Ensemble probability: 0.428\n", + " - Codon: GAA\n", + " 4. Position 18: \n", + " - Short probability: 0.369\n", + " - Long probability: 0.510\n", + " - Ensemble probability: 0.426\n", + " - Codon: GTC\n", + " 5. Position 105: \n", + " - Short probability: 0.248\n", + " - Long probability: 0.671\n", + " - Ensemble probability: 0.418\n", + " - Codon: ACT\n", "\n", - "📊 可视化分析完成！\n", - "图表包含热图和条形图，展示了整个序列的PRF预测概率分布。\n" + "📊 Visualization analysis complete!\n", + "The chart contains heatmaps and bar charts showing the PRF prediction probability distribution across the entire sequence.\n" ] } ], @@ -723,7 +765,7 @@ ] }, { - "cell_type": "raw", + "cell_type": "markdown", "metadata": { "vscode": { "languageId": "raw" @@ -915,7 +957,7 @@ ], "metadata": { "kernelspec": { - "display_name": "tf200", + "display_name": "fs", "language": "python", "name": "python3" }, @@ -929,7 +971,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.9.23" } }, "nbformat": 4, diff --git a/README.md b/README.md index 173cc3d..a4ada64 100644 --- a/README.md +++ b/README.md @@ -267,9 +267,9 @@ This project is licensed under the MIT License - see the [LICENSE](LICENSE) file ## 🆘 Support -- **Issues**: [GitHub Issues](https://github.com/your-org/FScanpy/issues) - **Documentation**: [Tutorial](tutorial/tutorial.md) -- **Examples**: [Demo Notebook](FScanpy_Demo.ipynb) +- **Usage Example**: [Demo Notebook](FScanpy_Demo.ipynb) +- **Predict Result Explain**: [Predict Result Explain](tutorial/predict_sample.ipynb) ## 🏗️ Dependencies diff --git a/example_plot_prediction.py b/example_plot_prediction.py deleted file mode 100644 index 40f8e0c..0000000 --- a/example_plot_prediction.py +++ /dev/null @@ -1,362 +0,0 @@ -#!/usr/bin/env python3 -""" -FScanpy 序列预测绘图示例 - -展示如何使用新的 plot_prf_prediction 函数绘制序列的移码概率预测结果 -包含集成权重参数的使用示例 -""" - -import matplotlib.pyplot as plt -import os -from FScanpy import plot_prf_prediction, PRFPredictor - -def example_basic_plotting(): - """基础绘图示例""" - print("=" * 50) - print("基础绘图示例") - print("=" * 50) - - # 示例序列（可以替换为您的实际序列） - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - ) - - try: - # 使用默认参数绘图 (0.4:0.6 集成权重比例) - results, fig = plot_prf_prediction( - sequence=example_sequence, - title="示例序列的移码概率预测 (默认集成权重 4:6)" - ) - - print(f"预测完成！共处理 {len(results)} 个位置") - print(f"满足阈值条件的位点数: {len(results[results['Ensemble_Probability'] > 0])}") - print(f"使用集成权重比例: Short模型 0.4, Long模型 0.6") - - # 显示图片 - plt.show() - - return results, fig - - except Exception as e: - print(f"绘图过程中出错: {str(e)}") - return None, None - -def example_custom_ensemble_weights(): - """自定义集成权重示例""" - print("=" * 50) - print("自定义集成权重绘图示例") - print("=" * 50) - - # 示例序列 - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - ) - - # 测试不同的集成权重比例 - weight_configs = [ - (0.2, "Long模型主导 (2:8)"), - (0.5, "等权重组合 (5:5)"), - (0.7, "Short模型主导 (7:3)") - ] - - for ensemble_weight, description in weight_configs: - print(f"\n测试集成权重配置: {description}") - try: - results, fig = plot_prf_prediction( - sequence=example_sequence, - ensemble_weight=ensemble_weight, - title=f"移码概率预测 - {description}", - figsize=(14, 7) - ) - - print(f"预测完成！共处理 {len(results)} 个位置") - print(f"满足阈值条件的位点数: {len(results[results['Ensemble_Probability'] > 0])}") - - # 显示统计信息 - print("预测统计信息:") - print(f" Short模型平均概率: {results['Short_Probability'].mean():.3f}") - print(f" Long模型平均概率: {results['Long_Probability'].mean():.3f}") - print(f" 集成平均概率: {results['Ensemble_Probability'].mean():.3f}") - print(f" 集成权重比例: Short:{ensemble_weight:.1f}, Long:{1-ensemble_weight:.1f}") - - plt.show() - - except Exception as e: - print(f"集成权重 {ensemble_weight} 绘图时出错: {str(e)}") - -def example_ensemble_comparison(): - """集成权重对比示例""" - print("=" * 50) - print("集成权重对比绘图示例") - print("=" * 50) - - # 示例序列 - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - ) - - try: - # 创建预测器实例 - predictor = PRFPredictor() - - # 测试三种不同集成权重 - weights = [0.3, 0.4, 0.6] - weight_names = ["Long主导 (3:7)", "默认权重 (4:6)", "Short主导 (6:4)"] - - # 创建对比图 - fig, axes = plt.subplots(3, 1, figsize=(15, 12)) - fig.suptitle('不同集成权重配置的预测结果对比', fontsize=16) - - all_results = [] - - for i, (weight, name) in enumerate(zip(weights, weight_names)): - # 获取预测结果 - results = predictor.predict_sequence( - sequence=example_sequence, - ensemble_weight=weight - ) - all_results.append(results) - - # 绘制条形图 - ax = axes[i] - ax.bar(results['Position'], results['Ensemble_Probability'], - alpha=0.7, color=f'C{i}', width=2) - ax.set_title(f'{name} - 平均概率: {results["Ensemble_Probability"].mean():.3f}') - ax.set_ylabel('概率') - ax.grid(True, alpha=0.3) - ax.set_ylim(0, 1) - - if i == len(weights) - 1: - ax.set_xlabel('序列位置') - - plt.tight_layout() - plt.show() - - # 打印对比统计 - print("\n集成权重对比统计:") - for i, (weight, name, results) in enumerate(zip(weights, weight_names, all_results)): - print(f"{name}:") - print(f" 平均集成概率: {results['Ensemble_Probability'].mean():.3f}") - print(f" 最大集成概率: {results['Ensemble_Probability'].max():.3f}") - print(f" 非零预测数量: {(results['Ensemble_Probability'] > 0).sum()}") - - return all_results, fig - - except Exception as e: - print(f"集成权重对比时出错: {str(e)}") - return None, None - -def example_save_plot(): - """保存图片示例""" - print("=" * 50) - print("保存图片示例") - print("=" * 50) - - # 创建保存目录 - save_dir = "prediction_plots" - os.makedirs(save_dir, exist_ok=True) - - # 示例序列 - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - "CTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - ) - - try: - # 保存不同集成权重配置的图片 - weight_configs = [ - (0.3, "long_dominant"), - (0.5, "equal_weight"), - (0.7, "short_dominant") - ] - - for ensemble_weight, file_suffix in weight_configs: - save_path = os.path.join(save_dir, f"prediction_{file_suffix}.png") - results, fig = plot_prf_prediction( - sequence=example_sequence, - short_threshold=0.6, - long_threshold=0.75, - ensemble_weight=ensemble_weight, - title=f"移码概率预测 (集成权重 {ensemble_weight:.1f}:{1-ensemble_weight:.1f})", - save_path=save_path, - dpi=300 - ) - - print(f"图片已保存至: {save_path}") - - # 不显示图片，直接关闭 - plt.close(fig) - - print("所有集成权重配置的图片都已保存完成") - return True - - except Exception as e: - print(f"保存图片过程中出错: {str(e)}") - return False - -def example_direct_predictor_usage(): - """直接使用PRFPredictor类的示例""" - print("=" * 50) - print("直接使用PRFPredictor类绘图示例") - print("=" * 50) - - try: - # 直接创建预测器实例 - predictor = PRFPredictor() - - # 示例序列 - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - "AGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCTAGCTAGCTAGCTAG" - ) - - # 使用类方法绘图，展示自定义集成权重 - results, fig = predictor.plot_sequence_prediction( - sequence=example_sequence, - short_threshold=0.65, - long_threshold=0.8, - ensemble_weight=0.3, # 自定义集成权重 - title="使用PRFPredictor类的绘图结果 (集成权重 3:7)" - ) - - print(f"预测完成！共处理 {len(results)} 个位置") - print(f"使用集成权重比例: Short:{0.3:.1f}, Long:{0.7:.1f}") - - # 显示详细结果 - print("\n前10个预测结果:") - columns_to_show = ['Position', 'Short_Probability', 'Long_Probability', 'Ensemble_Probability'] - print(results[columns_to_show].head(10)) - - # 显示集成权重信息 - if 'Ensemble_Weights' in results.columns: - print(f"\n集成权重配置: {results['Ensemble_Weights'].iloc[0]}") - - plt.show() - - return results, fig - - except Exception as e: - print(f"使用PRFPredictor类时出错: {str(e)}") - return None, None - -def example_new_api_usage(): - """新API使用示例""" - print("=" * 50) - print("新API方法使用示例") - print("=" * 50) - - try: - # 直接创建预测器实例 - predictor = PRFPredictor() - - # 示例序列 - example_sequence = ( - "ATGCGTACGTTAGCGATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGC" - "GATCGATCGTAGCTAGCTAGCTAGCTAGCTAGCTAGCTAGCGATCGATCGTAGCT" - ) - - print("1. 使用新的 predict_sequence() 方法:") - results = predictor.predict_sequence( - sequence=example_sequence, - ensemble_weight=0.3 - ) - - print(f" 序列预测完成: {len(results)} 个位置") - print(f" 主要输出字段: {[col for col in results.columns if 'Probability' in col]}") - - print("\n2. 使用新的 predict_regions() 方法:") - # 模拟一些399bp区域序列 - region_sequences = [example_sequence + "A" * (399 - len(example_sequence))] - region_results = predictor.predict_regions( - sequences=region_sequences, - ensemble_weight=0.4 - ) - - print(f" 区域预测完成: {len(region_results)} 个序列") - print(f" 主要输出字段: {[col for col in region_results.columns if 'Probability' in col or 'Sequence' in col]}") - - # 显示统计 - print("\n3. 结果统计:") - print(f" 序列预测平均集成概率: {results['Ensemble_Probability'].mean():.3f}") - print(f" 区域预测平均集成概率: {region_results['Ensemble_Probability'].mean():.3f}") - - return results, region_results - - except Exception as e: - print(f"新API使用时出错: {str(e)}") - return None, None - -def main(): - """主函数""" - print("FScanpy 序列预测绘图功能演示") - print("=" * 60) - print("新功能：规范化的集成权重参数 (ensemble_weight)") - print("权重范围：0.0 到 1.0 (对应 Short模型的权重，Long模型权重 = 1 - ensemble_weight)") - print("新命名：Ensemble_Probability 替代 Voting_Probability") - print("=" * 60) - - examples = [ - ("1. 基础绘图示例", example_basic_plotting), - ("2. 自定义集成权重示例", example_custom_ensemble_weights), - ("3. 集成权重对比示例", example_ensemble_comparison), - ("4. 保存图片示例", example_save_plot), - ("5. 直接使用PRFPredictor类示例", example_direct_predictor_usage), - ("6. 新API方法使用示例", example_new_api_usage) - ] - - for name, func in examples: - print(f"\n{name}") - try: - result = func() - if result is not None and result != False: - print("✓ 示例执行成功") - else: - print("✗ 示例执行失败") - except Exception as e: - print(f"✗ 示例执行出错: {str(e)}") - - print("-" * 50) - - print("\n演示完成！") - print("\n📊 新功能总结:") - print("1. plot_prf_prediction(): 便捷的绘图函数") - print("2. PRFPredictor.plot_sequence_prediction(): 类方法绘图") - print("3. PRFPredictor.predict_sequence(): 序列滑动窗口预测（替代predict_full）") - print("4. PRFPredictor.predict_regions(): 区域批量预测（替代predict_region）") - print("5. 支持自定义阈值、标题、保存路径等参数") - print("6. 新增 ensemble_weight 参数，可调节两个模型的集成权重比例") - print("\n⚖️ 集成权重示例:") - print(" - ensemble_weight=0.2: Short模型20%, Long模型80% (Long主导)") - print(" - ensemble_weight=0.4: Short模型40%, Long模型60% (默认平衡)") - print(" - ensemble_weight=0.5: Short模型50%, Long模型50% (等权重)") - print(" - ensemble_weight=0.7: Short模型70%, Long模型30% (Short主导)") - print("\n📂 输出字段:") - print(" - Short_Probability: Short模型(HistGB)预测概率") - print(" - Long_Probability: Long模型(BiLSTM-CNN)预测概率") - print(" - Ensemble_Probability: 集成预测概率（主要结果）") - print(" - Ensemble_Weights: 权重配置信息") - print(" - Short_Sequence: 33bp序列") - print(" - Long_Sequence: 399bp序列") - print("7. 自动保存PNG和PDF两种格式") - -if __name__ == "__main__": - main() \ No newline at end of file diff --git a/predict_sample.ipynb b/tutorial/predict_sample.ipynb similarity index 79% rename from predict_sample.ipynb rename to tutorial/predict_sample.ipynb index 1e3d67a..de60113 100644 --- a/predict_sample.ipynb +++ b/tutorial/predict_sample.ipynb @@ -2,9 +2,62 @@ "cells": [ { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2025-08-14 15:56:50.631778: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n", + "2025-08-14 15:56:50.632231: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-08-14 15:56:50.684833: I tensorflow/core/platform/cpu_feature_guard.cc:210] This TensorFlow binary is optimized to use available CPU instructions in performance-critical operations.\n", + "To enable the following instructions: AVX2 AVX512F AVX512_VNNI FMA, in other operations, rebuild TensorFlow with the appropriate compiler flags.\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/attr_value.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/resource_handle.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor_shape.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/types.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/full_type.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/function.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/node_def.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/op_def.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/graph.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/graph_debug_info.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/versions.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/config.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at xla/tsl/protobuf/coordination_config.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/cost_graph.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/step_stats.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/allocation_description.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/framework/tensor_description.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/cluster.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/google/protobuf/runtime_version.py:98: UserWarning: Protobuf gencode version 5.28.3 is exactly one major version older than the runtime version 6.31.1 at tensorflow/core/protobuf/debug.proto. Please update the gencode to avoid compatibility violations in the next runtime release.\n", + " warnings.warn(\n", + "2025-08-14 15:56:52.092041: I tensorflow/core/util/port.cc:153] oneDNN custom operations are on. You may see slightly different numerical results due to floating-point round-off errors from different computation orders. To turn them off, set the environment variable `TF_ENABLE_ONEDNN_OPTS=0`.\n", + "2025-08-14 15:56:52.093165: I external/local_xla/xla/tsl/cuda/cudart_stub.cc:31] Could not find cuda drivers on your machine, GPU will not be used.\n" + ] + } + ], "source": [ "import pandas as pd\n", "import matplotlib.pyplot as plt\n", @@ -17,40 +70,33 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - " GB_Probability CNN_Probability Voting_Probability Position Codon \\\n", - "0 0.883519 0.950972 0.923991 114 GCC \n", - "1 0.910635 0.988631 0.957433 1794 CCC \n", - "2 0.890379 0.979877 0.944078 1821 AAC \n", - "3 0.953772 0.962459 0.958984 1881 AAC \n", - "4 0.941618 0.946840 0.944751 1194 CTT \n", - "\n", - " 33bp \\\n", - "0 TCTGGAAGAAGTAAACGCCGAGCTGGAACAGCC \n", - "1 GGGGCAGTCCCCTAGCCCCGCTCAAAAGGGGGA \n", - "2 ACCACCCCATCAGGGAAACCGGGTGGAGGGGCC \n", - "3 CACCGGGCCAGGAAATAACCCAGTATTCCCAGT \n", - "4 ACTAATAGAGGGGGGACTTAGCGCCCCCCAAAC \n", + " Position Codon 33bp \\\n", + "0 114 GCC TCTGGAAGAAGTAAACGCCGAGCTGGAACAGCC \n", + "1 1794 CCC GGGGCAGTCCCCTAGCCCCGCTCAAAAGGGGGA \n", + "2 234 GTC CCACAAGTCTCGTTTCGTCGATCTTCTGGAGTT \n", + "3 129 TCC GGCTGCGGTTGCAAACTCCGAAGTCGATGCACT \n", + "4 216 GAC GGAGCAGCGGGTAAATGACCTCTTGGAGCTGTT \n", "\n", " 399bp Sequence_ID \\\n", "0 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN... 0 \n", "1 GACAGGACACATCAGAAAAGACTGTAAGGATGAAAAGGGCTCAAAA... 1 \n", - "2 AAATAAAGAGAAAGGAGGGTGTTGCTTTAAATGCGGTAAAAAAGGA... 2 \n", - "3 CCTGTACCTCCCTGAGGCAAAAAGGCCGCCTGTAATCTTGCCAATA... 3 \n", - "4 GCCCGGGCCTCGGCAACCGGCCCCCAAAAGGCCCCCCCCGGGACCA... 4 \n", + "2 CAATTCCAATTCCATGTCGATGATCGGTCAAAGCCCCCCGTGCTGC... 5 \n", + "3 NNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNNN... 12 \n", + "4 TGAACTTAAGAGCCGCATTCTTTCCGATATGGTGCGACTTGACATT... 14 \n", "\n", " Full_Sequence \n", "0 ATGTTTGAAATTAACCCGGTGAATAACCGCATTCAGGACCTCACGG... \n", "1 ATGGGGGTCTCGGGATCAAAAGGGCAGAAACTCTTTGTTTCTGTTC... \n", - "2 ATGGGGCAAGAATTAAGCCAGCATGAACGTTATGTAGAACAATTGA... \n", - "3 ATGGGCCAAATCTTTTCCCGTAGCGCTAGCCCTATTCCGCGGCCGC... \n", - "4 ATGGGAAATTCCCCCTCCTATAACCCCCCCGCTGGTATCTCCCCCT... \n" + "2 ATGTCGAGTAGTATCGTCCTCAGTAATAATAATTCCAATTCCAATT... \n", + "3 ATGAACAAAGAAAATGTCATTACCCTGGACAATCCGGTCAAACGTG... \n", + "4 ATGCAAGACATATTAAGTGAACTTAAGAGCCGCATTCTTTCCGATA... \n" ] } ], @@ -68,32 +114,21 @@ "name": "stderr", "output_type": "stream", "text": [ - "c:\\Users\\31598\\.conda\\envs\\fs\\lib\\site-packages\\sklearn\\base.py:440: InconsistentVersionWarning: Trying to unpickle estimator _BinMapper from version 1.6.0 when using version 1.7.0. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "/mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/predictor.py:23: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator _BinMapper from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", " warnings.warn(\n", - "c:\\Users\\31598\\.conda\\envs\\fs\\lib\\site-packages\\sklearn\\base.py:440: InconsistentVersionWarning: Trying to unpickle estimator HistGradientBoostingClassifier from version 1.6.0 when using version 1.7.0. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", + "/home/guest01/.conda/envs/fs/lib/python3.9/site-packages/sklearn/base.py:380: InconsistentVersionWarning: Trying to unpickle estimator HistGradientBoostingClassifier from version 1.6.0 when using version 1.6.1. This might lead to breaking code or invalid results. Use at your own risk. For more info please refer to:\n", "https://scikit-learn.org/stable/model_persistence.html#security-maintainability-limitations\n", " warnings.warn(\n", - "Exception in thread Thread-9 (_readerthread):\n", - "Traceback (most recent call last):\n", - " File \"c:\\Users\\31598\\.conda\\envs\\fs\\lib\\threading.py\", line 1016, in _bootstrap_inner\n", - " self.run()\n", - " File \"c:\\Users\\31598\\.conda\\envs\\fs\\lib\\site-packages\\ipykernel\\ipkernel.py\", line 766, in run_closure\n", - " _threading_Thread_run(self)\n", - " File \"c:\\Users\\31598\\.conda\\envs\\fs\\lib\\threading.py\", line 953, in run\n", - " self._target(*self._args, **self._kwargs)\n", - " File \"c:\\Users\\31598\\.conda\\envs\\fs\\lib\\subprocess.py\", line 1515, in _readerthread\n", - " buffer.append(fh.read())\n", - " File \"c:\\Users\\31598\\.conda\\envs\\fs\\lib\\codecs.py\", line 322, in decode\n", - " (result, consumed) = self._buffer_decode(data, self.errors, final)\n", - "UnicodeDecodeError: 'utf-8' codec can't decode byte 0xce in position 4: invalid continuation byte\n", - "a:\\Code\\fscanpy-package\\FScanpy\\predictor.py:347: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", + "/mnt/lmpbe/guest01/FScanpy-package-main/FScanpy/predictor.py:347: UserWarning: This figure includes Axes that are not compatible with tight_layout, so results might be incorrect.\n", " plt.tight_layout()\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -394,7 +429,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.18" + "version": "3.9.23" } }, "nbformat": 4,