import pandas as pd
import numpy as np

# 合并不同组学数据
rna_data = pd.read_csv('rna_expression.csv', index_col=0)
protein_data = pd.read_csv('protein_abundance.csv', index_col=0)

# 标准化
from sklearn.preprocessing import StandardScaler
scaler = StandardScaler()

rna_scaled = scaler.fit_transform(rna_data)
protein_scaled = scaler.fit_transform(protein_data)

# 合并
combined_data = np.hstack([rna_scaled, protein_scaled])

# 分别进行差异分析
from scipy import stats

# RNA-seq 差异分析
rna_pvalues = []
for gene in rna_data.columns:
    t_stat, p_val = stats.ttest_ind(
        rna_data[gene][group1],
        rna_data[gene][group2]
    )
    rna_pvalues.append(p_val)

# 蛋白质组差异分析
protein_pvalues = []
for protein in protein_data.columns:
    t_stat, p_val = stats.ttest_ind(
        protein_data[protein][group1],
        protein_data[protein][group2]
    )
    protein_pvalues.append(p_val)

# 整合结果
from scipy.stats import combine_pvalues
combined_pval = combine_pvalues([rna_pvalues, protein_pvalues], 
                                method='fisher')

from mofapy2.run.entry_point import entry_point

# 准备数据
data = {
    'RNA': rna_matrix,
    'Protein': protein_matrix,
    'Metabolite': metabolite_matrix
}

# 运行 MOFA
ent = entry_point()
ent.set_data_options(scale_groups=False, scale_views=True)
ent.set_data_matrix(data)
ent.set_model_options(factors=10)
ent.build()
ent.run()

# 可视化因子
ent.plot_variance_explained()
ent.plot_factor_cor()

import pandas as pd
import numpy as np
from sklearn.preprocessing import StandardScaler

# 加载数据
rna_seq = pd.read_csv('tcga_rna_seq.csv', index_col=0)
cnv = pd.read_csv('tcga_cnv.csv', index_col=0)
methylation = pd.read_csv('tcga_methylation.csv', index_col=0)
clinical = pd.read_csv('tcga_clinical.csv', index_col=0)

# 确保样本一致
common_samples = list(set(rna_seq.columns) & 
                     set(cnv.columns) & 
                     set(methylation.columns))

rna_seq = rna_seq[common_samples]
cnv = cnv[common_samples]
methylation = methylation[common_samples]

from mofapy2.run.entry_point import entry_point

# 准备数据
data_dict = {
    'RNA': rna_seq.T.values,
    'CNV': cnv.T.values,
    'Methylation': methylation.T.values
}

# 初始化 MOFA
ent = entry_point()
ent.set_data_options(
    scale_groups=False,
    scale_views=True
)
ent.set_data_matrix(data_dict, likelihoods=['gaussian']*3)

# 设置模型参数
ent.set_model_options(
    factors=15,
    spikeslab_weights=True,
    ard_factors=True
)

# 训练模型
ent.build()
ent.run()

# 保存模型
ent.save('mofa_model.hdf5')

# 加载模型
from mofapy2.run.entry_point import entry_point
model = entry_point()
model.load('mofa_model.hdf5')

# 查看方差解释
model.plot_variance_explained(
    plot_total=True,
    x='view',
    y='factor'
)

# 提取因子值
factors = model.get_factors()

# 与临床特征关联
import scipy.stats as stats
for i in range(factors.shape[1]):
    corr, pval = stats.spearmanr(
        factors[:, i],
        clinical['survival_time']
    )
    print(f"Factor {i+1}: r={corr:.3f}, p={pval:.3e}")

from sklearn.ensemble import RandomForestClassifier
from sklearn.model_selection import cross_val_score

# 合并特征
X = np.hstack([rna_scaled, protein_scaled, metabolite_scaled])
y = sample_labels

# 训练模型
rf = RandomForestClassifier(n_estimators=100, random_state=42)
scores = cross_val_score(rf, X, y, cv=5)

print(f"准确率: {scores.mean():.3f} (+/- {scores.std():.3f})")

# 特征重要性
rf.fit(X, y)
feature_importance = rf.feature_importances_

import torch
import torch.nn as nn

class MultiOmicsNet(nn.Module):
    def __init__(self, rna_dim, protein_dim, metabolite_dim, n_classes):
        super().__init__()
        
        # 各组学的编码器
        self.rna_encoder = nn.Sequential(
            nn.Linear(rna_dim, 256),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(256, 64)
        )
        
        self.protein_encoder = nn.Sequential(
            nn.Linear(protein_dim, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, 64)
        )
        
        self.metabolite_encoder = nn.Sequential(
            nn.Linear(metabolite_dim, 64),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(64, 64)
        )
        
        # 整合层
        self.fusion = nn.Sequential(
            nn.Linear(64*3, 128),
            nn.ReLU(),
            nn.Dropout(0.3),
            nn.Linear(128, n_classes)
        )
    
    def forward(self, rna, protein, metabolite):
        rna_feat = self.rna_encoder(rna)
        protein_feat = self.protein_encoder(protein)
        metabolite_feat = self.metabolite_encoder(metabolite)
        
        # 拼接特征
        combined = torch.cat([rna_feat, protein_feat, metabolite_feat], dim=1)
        output = self.fusion(combined)
        return output

# 训练模型
model = MultiOmicsNet(rna_dim=5000, protein_dim=1000, 
                     metabolite_dim=200, n_classes=3)
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(model.parameters(), lr=0.001)

import seaborn as sns
import matplotlib.pyplot as plt

# 相关性热图
fig, axes = plt.subplots(1, 3, figsize=(18, 5))

sns.heatmap(rna_data.corr(), ax=axes[0], cmap='RdBu_r', center=0)
axes[0].set_title('RNA-seq 相关性')

sns.heatmap(protein_data.corr(), ax=axes[1], cmap='RdBu_r', center=0)
axes[1].set_title('蛋白质组相关性')

sns.heatmap(metabolite_data.corr(), ax=axes[2], cmap='RdBu_r', center=0)
axes[2].set_title('代谢组相关性')

plt.tight_layout()
plt.show()

import networkx as nx

# 构建跨组学网络
G = nx.Graph()

# 添加节点
for gene in top_genes:
    G.add_node(gene, type='RNA')
for protein in top_proteins:
    G.add_node(protein, type='Protein')

# 添加边（基于相关性）
for gene in top_genes:
    for protein in top_proteins:
        corr = np.corrcoef(rna_data[gene], protein_data[protein])[0,1]
        if abs(corr) > 0.7:
            G.add_edge(gene, protein, weight=abs(corr))

# 可视化
pos = nx.spring_layout(G)
nx.draw(G, pos, node_color=['red' if G.nodes[n]['type']=='RNA' else 'blue' 
                            for n in G.nodes()],
        with_labels=True, node_size=500)
plt.show()

import scanpy as sc

# 读取数据
adata = sc.read_10x_h5('filtered_feature_bc_matrix.h5')

# 标准流程
sc.pp.filter_cells(adata, min_genes=200)
sc.pp.filter_genes(adata, min_cells=3)
sc.pp.normalize_total(adata)
sc.pp.log1p(adata)
sc.pp.highly_variable_genes(adata)
sc.tl.pca(adata)
sc.pp.neighbors(adata)
sc.tl.umap(adata)
sc.tl.leiden(adata)

import matplotlib.pyplot as plt
import seaborn as sns

sns.set_style("whitegrid")
plt.figure(figsize=(10, 8))
sns.scatterplot(data=df, x='UMAP_1', y='UMAP_2', hue='cluster')
plt.title('UMAP Visualization')
plt.show()

rule align:
    input:
        "data/{sample}.fastq"
    output:
        "results/{sample}.bam"
    shell:
        "bwa mem ref.fa {input} | samtools sort -o {output}"