File size: 5,183 Bytes
5e449c6
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
为未被现有 module 覆盖的基因创建额外的 module
确保所有模型基因都能参与训练

使用方法:
    python create_uncovered_modules.py \
        --merged_modules module_data_all/merged_modules.json \
        --output module_data_all/merged_modules_full.json \
        --module_size 50
"""

import json
import os
import csv
import argparse

def create_uncovered_modules(
    merged_modules_path,
    gene_list_path,
    gene_mapping_path,
    output_path,
    module_size=50,
    verbose=True
):
    """
    为未被覆盖的基因创建额外的 module

    Args:
        merged_modules_path: 已合并的 module 文件路径
        gene_list_path: 模型基因列表路径
        gene_mapping_path: 基因映射文件路径
        output_path: 输出文件路径
        module_size: 新 module 的大小
        verbose: 是否打印详细信息
    """
    # 加载模型基因列表
    with open(gene_list_path, 'r') as f:
        model_genes = set(line.strip() for line in f)

    # 加载已有的 modules
    with open(merged_modules_path, 'r') as f:
        modules = json.load(f)

    # 加载基因映射 (symbol -> ensembl)
    symbol_to_ens = {}
    ens_to_symbol = {}
    with open(gene_mapping_path, 'r') as f:
        reader = csv.DictReader(f)
        for row in reader:
            symbol = row.get('Approved symbol', '').strip()
            ens_id = row.get('Ensembl gene ID', '').strip()
            if symbol and ens_id:
                symbol_to_ens[symbol] = ens_id
                ens_to_symbol[ens_id] = symbol

    # 找出已被覆盖的基因
    covered_genes_ens = set()
    for module_name, genes in modules.items():
        for g in genes:
            ens_id = symbol_to_ens.get(g)
            if ens_id and ens_id in model_genes:
                covered_genes_ens.add(ens_id)
            elif g in model_genes:
                covered_genes_ens.add(g)

    # 找出未被覆盖的基因
    uncovered_genes = model_genes - covered_genes_ens
    uncovered_genes = sorted(list(uncovered_genes))

    if verbose:
        print(f"模型基因总数: {len(model_genes)}")
        print(f"已被覆盖的基因: {len(covered_genes_ens)} ({len(covered_genes_ens)/len(model_genes)*100:.1f}%)")
        print(f"未被覆盖的基因: {len(uncovered_genes)} ({len(uncovered_genes)/len(model_genes)*100:.1f}%)")

    # 为未覆盖的基因创建新的 modules
    # 使用 Ensembl ID(因为模型使用的是 Ensembl ID)
    new_modules = {}
    num_new_modules = (len(uncovered_genes) + module_size - 1) // module_size

    for i in range(num_new_modules):
        start_idx = i * module_size
        end_idx = min((i + 1) * module_size, len(uncovered_genes))
        module_genes = uncovered_genes[start_idx:end_idx]

        # 尝试转换为 symbol(如果有映射的话),否则保持 Ensembl ID
        module_genes_final = []
        for g in module_genes:
            symbol = ens_to_symbol.get(g)
            if symbol:
                module_genes_final.append(symbol)
            else:
                module_genes_final.append(g)

        new_modules[f"uncovered_module_{i+1:04d}"] = module_genes_final

    if verbose:
        print(f"\n创建了 {len(new_modules)} 个新 module (每个约 {module_size} 个基因)")

    # 合并原有 modules 和新 modules
    merged_modules = {**modules, **new_modules}

    # 保存
    os.makedirs(os.path.dirname(output_path) if os.path.dirname(output_path) else '.', exist_ok=True)
    with open(output_path, 'w', encoding='utf-8') as f:
        json.dump(merged_modules, f, indent=2)

    if verbose:
        print(f"\n最终结果:")
        print(f"  原有 modules: {len(modules)}")
        print(f"  新增 modules: {len(new_modules)}")
        print(f"  总 modules: {len(merged_modules)}")
        print(f"  保存到: {output_path}")

    return merged_modules

def main():
    parser = argparse.ArgumentParser(description='Create modules for uncovered genes')
    parser.add_argument('--merged_modules', type=str,
                        default='module_data_all/merged_modules.json',
                        help='Path to merged modules JSON file')
    parser.add_argument('--gene_list', type=str,
                        default='../selected_genes_27k.txt',
                        help='Path to model gene list file')
    parser.add_argument('--gene_mapping', type=str,
                        default='../gene2ens.csv',
                        help='Path to gene mapping CSV file')
    parser.add_argument('--output', '-o', type=str,
                        default='module_data_all/merged_modules_full.json',
                        help='Output file path')
    parser.add_argument('--module_size', type=int, default=50,
                        help='Size of new modules for uncovered genes')

    args = parser.parse_args()

    create_uncovered_modules(
        merged_modules_path=args.merged_modules,
        gene_list_path=args.gene_list,
        gene_mapping_path=args.gene_mapping,
        output_path=args.output,
        module_size=args.module_size
    )

if __name__ == '__main__':
    main()