Model files

Attention_Extracter.py

@@ -0,0 +1,47 @@
+import torch
+import pickle
+import numpy as np
+
+class Attention_Extracter:
+    def __init__(self, graph_data_dict_path, encoder_model, gpu=False):
+        self.torch_device = 'cuda' if gpu else 'cpu'
+            
+        self.graph_data_dict = torch.load(graph_data_dict_path)
+        self.encoder_model = encoder_model
+        self.encoder_model.to(self.torch_device)
+        self.encoder_model.eval()
+        self.latent_feat_dict, self.attention_scores1 = self.extract_latent_attention_features()
+
+    def extract_latent_attention_features(self):
+        latent_features = {}
+        attention_scores1 = {}
+        
+        with torch.no_grad():
+            for graph_id, data in self.graph_data_dict.items():
+                data = data.to(self.torch_device)
+                z, attention_weights = self.encoder_model(data.x, data.edge_index, data.edge_attr)
+                latent_features[graph_id] = z.cpu()
+
+                # Handling the case where attention_weights is a tuple or other data structure
+                if isinstance(attention_weights, (list, tuple)):
+                    attention_scores1[graph_id] = [aw for aw in attention_weights]
+                else:
+                    attention_scores1[graph_id] = attention_weights.cpu()
+
+        return latent_features, attention_scores1
+    
+    def load_edge_indices(self, glist_path, edge_matrix_path):
+        with open(glist_path, 'rb') as f:
+            glist = pickle.load(f)
+
+        edge_matrix = np.load(edge_matrix_path)
+        edge_matrix = torch.tensor(edge_matrix, dtype=torch.float)
+        edge_index = torch.nonzero(edge_matrix, as_tuple=False).t().contiguous()
+        edge_indices_dict = {}
+
+        for i in range(edge_index.shape[1]):
+            index1, index2 = edge_index[0, i].item(), edge_index[1, i].item()
+            gene1, gene2 = glist[index1], glist[index2]
+            edge_indices_dict[(index1, index2)] = (gene1, gene2)
+
+        return edge_indices_dict

EdgeWeightPredictorModel.py

@@ -0,0 +1,39 @@
+from transformers import PreTrainedModel
+from OmicsConfig import OmicsConfig
+from transformers import PretrainedConfig, PreTrainedModel
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import GATv2Conv
+from torch_geometric.data import Batch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch_geometric.utils import negative_sampling
+from torch.nn.functional import cosine_similarity
+from torch.optim.lr_scheduler import StepLR
+
+
+class EdgeWeightPredictorModel(PreTrainedModel):
+    config_class = OmicsConfig
+    base_model_prefix = "edge_weight_predictor"
+
+    def __init__(self, config):
+        super().__init__(config)
+        layers = []
+        input_size = 2 * config.out_channels
+        for hidden_size, activation in zip(config.edge_decoder_hidden_sizes, config.edge_decoder_activations):
+            layers.append(nn.Linear(input_size, hidden_size))
+            if activation == 'ReLU':
+                layers.append(nn.ReLU())
+            elif activation == 'Sigmoid':
+                layers.append(nn.Sigmoid())
+            elif activation == 'Tanh':
+                layers.append(nn.Tanh())
+            # Add more activations if needed
+            input_size = hidden_size
+        layers.append(nn.Linear(input_size, 1))
+        self.predictor = nn.Sequential(*layers)
+
+    def forward(self, z, edge_index):
+        edge_embeddings = torch.cat([z[edge_index[0]], z[edge_index[1]]], dim=-1)
+        return self.predictor(edge_embeddings)

GATv2DecoderModel.py

@@ -0,0 +1,38 @@
+from transformers import PreTrainedModel
+from OmicsConfig import OmicsConfig
+from transformers import PretrainedConfig, PreTrainedModel
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import GATv2Conv
+from torch_geometric.data import Batch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch_geometric.utils import negative_sampling
+from torch.nn.functional import cosine_similarity
+from torch.optim.lr_scheduler import StepLR
+
+from EdgeWeightPredictorModel import EdgeWeightPredictorModel
+
+class GATv2DecoderModel(PreTrainedModel):
+    config_class = OmicsConfig
+    base_model_prefix = "gatv2_decoder"
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.layers = nn.ModuleList([
+            nn.Linear(config.out_channels if i == 0 else config.out_channels, config.out_channels)
+            for i in range(config.num_layers)
+        ])
+        self.fc = nn.Linear(config.out_channels, config.original_feature_size)
+        self.edge_weight_predictor = EdgeWeightPredictorModel(config)
+
+    def forward(self, z):
+        for layer in self.layers:
+            z = layer(z)
+            z = F.relu(z)
+        x_reconstructed = self.fc(z)
+        return x_reconstructed
+
+    def predict_edge_weights(self, z, edge_index):
+        return self.edge_weight_predictor(z, edge_index)

GATv2EncoderModel.py

@@ -0,0 +1,32 @@
+from transformers import PreTrainedModel
+from OmicsConfig import OmicsConfig
+from transformers import PretrainedConfig, PreTrainedModel
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import GATv2Conv
+from torch_geometric.data import Batch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch_geometric.utils import negative_sampling
+from torch.nn.functional import cosine_similarity
+from torch.optim.lr_scheduler import StepLR
+
+
+class GATv2EncoderModel(PreTrainedModel):
+    config_class = OmicsConfig
+    base_model_prefix = "gatv2_encoder"
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.layers = nn.ModuleList([
+            GATv2Conv(config.in_channels if i == 0 else config.out_channels, config.out_channels, heads=1, concat=True, edge_dim=config.edge_attr_channels, add_self_loops=False)
+            for i in range(config.num_layers)
+        ])
+
+    def forward(self, x, edge_index, edge_attr):
+        attention_weights = []
+        for layer in self.layers:
+            x, attn_weights = layer(x, edge_index, edge_attr, return_attention_weights=True)
+            attention_weights.append(attn_weights)
+        return x, attention_weights

GraphAnalysis.py

@@ -0,0 +1,170 @@
+import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
+from sklearn.manifold import TSNE
+from lifelines.statistics import logrank_test
+from itertools import combinations
+import matplotlib.pyplot as plt
+from yellowbrick.cluster import KElbowVisualizer
+import pandas as pd
+import seaborn as sns
+from lifelines import KaplanMeierFitter
+import matplotlib.cm as cm
+import itertools
+import torch
+
+class GraphAnalysis:
+    def __init__(self, EXTRACTER):
+        self.extracter = EXTRACTER
+        self.process()
+        
+    def process(self):
+        latent_features_list = list(self.extracter.latent_feat_dict.values())
+        patient_list = list(self.extracter.latent_feat_dict.keys())
+        latentF = torch.stack(latent_features_list, dim=0)
+        self.latentF = np.squeeze(latentF.numpy())
+        self.pIDs = patient_list
+        self.df = pd.DataFrame(columns=['PC1','PC2','tX','tY','groups'], index=self.pIDs)
+        self.clnc_df = pd.read_csv('./data/survival.hnsc_data.csv').set_index('PatientID')
+        self.df = self.df.join(self.clnc_df)
+
+    def pca_tsne(self):
+        pca = PCA(n_components=2)
+        X_pca = pca.fit_transform(self.latentF)
+        self.df['PC1'] = X_pca[:,0]
+        self.df['PC2'] = X_pca[:,1]
+        tsne = TSNE(n_components=2)
+        X_tsne = tsne.fit_transform(self.latentF)
+        self.df['tX'] = X_tsne[:,0]
+        self.df['tY'] = X_tsne[:,1]
+        
+    def find_optimal_clusters(self, min_clusters=2, max_clusters=11, save_path='./results/kelbow'):
+        model = KMeans(random_state=42)
+        visualizer = KElbowVisualizer(model, k=(min_clusters, max_clusters))
+        visualizer.fit(self.latentF)
+        visualizer.show()
+        fig = visualizer.ax.get_figure()
+        fig.savefig(save_path + ".png", dpi=150)
+        fig.savefig(save_path + ".jpeg", format="jpeg", dpi=150)
+        self.optimal_clusters = visualizer.elbow_value_
+
+    def cluster_data(self):
+        if self.optimal_clusters is None:
+            raise ValueError("Please run 'find_optimal_clusters' method before clustering the data.")
+        kmeans = KMeans(n_clusters=self.optimal_clusters, random_state=0).fit(self.latentF)
+        self.labels = kmeans.labels_
+        self.df['groups'] = self.labels 
+        self.generate_color_list_based_on_median_survival()
+        
+    def cluster_data2(self, kclust):
+        kmeans = KMeans(n_clusters=kclust, random_state=0).fit(self.latentF)
+        self.labels = kmeans.labels_
+        self.df['groups'] = self.labels 
+        self.generate_color_list_based_on_median_survival()
+
+    def visualize_clusters(self):
+        plt.figure(figsize=(20,8))
+        plt.subplot(1,2,1)
+        sns.scatterplot(data=self.df, x='PC1', y='PC2', hue='groups', palette=self.color_list)
+        plt.subplot(1,2,2)
+        sns.scatterplot(data=self.df, x='tX', y='tY', hue='groups', palette=self.color_list)
+        
+    def save_visualize_clusters(self):
+        plt.figure(figsize=(10,8))
+        sns.scatterplot(data=self.df, x='PC1', y='PC2', hue='groups', palette=self.color_list)
+        plt.savefig('./results/temp_pca.jpeg', dpi=300)
+        plt.savefig('./results/temp_pca.png', dpi=300)
+        plt.close()
+        plt.figure(figsize=(10,8))
+        sns.scatterplot(data=self.df, x='tX', y='tY', hue='groups', palette=self.color_list)
+        plt.savefig('./results/temp_tsne.jpeg', dpi=300)
+        plt.savefig('./results/temp_tsne.png', dpi=300)
+
+    def map_group_to_color(group):
+        return self.color_list[group]
+        
+    def generate_color_list_based_on_median_survival(self):
+        groups = self.df['groups'].unique()
+        median_survival_times = {group: self.df[self.df['groups'] == group]['Overall Survival (Months)'].median() for group in groups}
+        sorted_groups = sorted(groups, key=median_survival_times.get, reverse=True)
+        vibgyor_colors = cm.rainbow(np.linspace(0, 1, len(groups)))
+        self.color_list = {group: color for group, color in zip(sorted_groups, vibgyor_colors)}
+        
+    def perform_log_rank_test(self, alpha=0.05):
+        if self.df is None:
+            raise ValueError("Please run 'cluster_data' or 'cluster_data2' method before performing log rank test.")
+        groups = self.df['groups'].unique()
+        significant_pairs = []
+        for pair in itertools.combinations(groups, 2):
+            group_a = self.df[self.df['groups'] == pair[0]]
+            group_b = self.df[self.df['groups'] == pair[1]]
+            results = logrank_test(group_a['Overall Survival (Months)'], group_b['Overall Survival (Months)'], group_a['Overall Survival Status'], group_b['Overall Survival Status'])
+            if results.p_value < alpha:
+                significant_pairs.append(pair)
+        self.significant_pairs = significant_pairs
+        return self.significant_pairs
+    
+    def generate_summary_table(self):
+        groups = self.df['groups'].unique()
+        summary_table = pd.DataFrame(columns=['Total number of patients', 'Alive', 'Deceased', 'Median survival time'], index=groups)
+        for group in groups:
+            group_data = self.df[self.df['groups'] == group]
+            total_patients = len(group_data)
+            alive = len(group_data[group_data['Overall Survival Status'] == 0])
+            deceased = len(group_data[group_data['Overall Survival Status'] == 1])
+            kmf = KaplanMeierFitter()
+            kmf.fit(group_data['Overall Survival (Months)'], group_data['Overall Survival Status'])
+            median_survival_time = kmf.median_survival_time_
+            summary_table.loc[group] = [total_patients, alive, deceased, median_survival_time]
+        return summary_table
+    
+    def plot_kaplan_meier(self, plot_for_groups=True, name='temp_k5'):
+        kmf = KaplanMeierFitter()
+        plt.figure(figsize=(8, 6))
+        plt.grid(False)
+        if plot_for_groups:
+            groups = sorted(self.df['groups'].unique())
+            for i, group in enumerate(groups):
+                group_data = self.df[self.df['groups'] == group]
+                kmf.fit(group_data['Overall Survival (Months)'], group_data['Overall Survival Status'], label=f'Group {group}')
+                kmf.plot(ci_show=False, linewidth=2, color=self.color_list[group])
+            plt.title("Kaplan-Meier Curves for Each Group")
+        else:
+            kmf.fit(self.df['Overall Survival (Months)'], self.df['Overall Survival Status'], label='All Data')
+            kmf.plot(ci_show=False, linewidth=2, color='black')
+            plt.title("Kaplan-Meier Curve for All Data")
+        plt.gca().set_facecolor('#f5f5f5')
+        plt.grid(color='lightgrey', linestyle='-', linewidth=0.5)
+        plt.xlabel("Overall Survival (Months)", fontweight='bold')
+        plt.ylabel("Survival Probability", fontweight='bold')
+        plt.legend()
+        plt.savefig('./results/{}_plan_meir.jpeg'.format(name), dpi=300)
+        plt.savefig('./results/{}_plan_meir.png'.format(name), dpi=300)
+        plt.show()
+        
+    def club_two_groups(self, primary_group, secondary_group):
+        self.df.loc[self.df['groups'] == secondary_group, 'groups'] = primary_group
+        unique_groups = sorted(self.df['groups'].unique())
+        mapping = {old: new for new, old in enumerate(unique_groups)}
+        self.df['groups'] = self.df['groups'].map(mapping)
+        self.generate_color_list_based_on_median_survival()
+        self.summary_table = self.generate_summary_table()
+
+    def plot_median_survival_bar(self, name='temp_k5'):
+        summary_df = self.generate_summary_table()
+        summary_df['group'] = summary_df.index
+        max_val = summary_df["Median survival time"].replace(np.inf, np.nan).max()
+        summary_df["Display Median"] = summary_df["Median survival time"].replace(np.inf, max_val * 1.1)
+        summary_df = summary_df.sort_index()
+        colors = [self.color_list[group] for group in summary_df.index]
+        num_groups = len(summary_df)
+        plt.figure(figsize=(6, num_groups * 0.8))
+        plt.grid(False)
+        sns.barplot(data=summary_df, y='group', x="Display Median", palette=colors, orient="h", order=summary_df.index)
+        plt.xlabel("Median Survival Time (Months)")
+        plt.ylabel("Groups")
+        plt.title("Median Survival Time by Group")
+        plt.tight_layout()
+        plt.savefig('./results/{}_median_survival.jpeg'.format(name), dpi=300)
+        plt.savefig('./results/{}_median_survival.png'.format(name), dpi=300)
+        plt.show()

MultiOmicsGraphAttentionAutoencoderModel.py

@@ -0,0 +1,155 @@
+from transformers import PreTrainedModel
+from OmicsConfig import OmicsConfig
+from transformers import PretrainedConfig, PreTrainedModel
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import GATv2Conv
+from torch_geometric.data import Batch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch_geometric.utils import negative_sampling
+from torch.nn.functional import cosine_similarity
+from torch.optim.lr_scheduler import StepLR
+
+from GATv2EncoderModel import GATv2EncoderModel
+from GATv2DecoderModel import GATv2DecoderModel
+from EdgeWeightPredictorModel import EdgeWeightPredictorModel
+
+
+class MultiOmicsGraphAttentionAutoencoderModel(PreTrainedModel):
+    config_class = OmicsConfig
+    base_model_prefix = "graph-attention-autoencoder"
+
+    def __init__(self, config):
+        super().__init__(config)
+        self.encoder = GATv2EncoderModel(config)
+        self.decoder = GATv2DecoderModel(config)
+        self.optimizer = AdamW(list(self.encoder.parameters()) + list(self.decoder.parameters()), lr=config.learning_rate)
+        self.scheduler = StepLR(self.optimizer, step_size=30, gamma=0.7)
+
+    def forward(self, x, edge_index, edge_attr):
+        z, attention_weights = self.encoder(x, edge_index, edge_attr)
+        x_reconstructed = self.decoder(z)
+        return x_reconstructed, attention_weights
+
+    def predict_edge_weights(self, z, edge_index):
+        return self.decoder.predict_edge_weights(z, edge_index)
+
+    def train_model(self, data_loader, device):
+        self.encoder.to(device)
+        self.decoder.to(device)
+        self.encoder.train()
+        self.decoder.train()
+        total_loss = 0
+        total_cosine_similarity = 0
+        loss_weight_node = 1.0
+        loss_weight_edge = 1.0
+        loss_weight_edge_attr = 1.0
+
+        for data in data_loader:
+            data = data.to(device)
+            self.optimizer.zero_grad()
+            z, attention_weights = self.encoder(data.x, data.edge_index, data.edge_attr)
+            x_reconstructed = self.decoder(z)
+            node_loss = graph_reconstruction_loss(x_reconstructed, data.x)
+            edge_loss = edge_reconstruction_loss(z, data.edge_index)
+            cos_sim = cosine_similarity(x_reconstructed, data.x, dim=-1).mean()
+            total_cosine_similarity += cos_sim.item()
+            pred_edge_weights = self.decoder.predict_edge_weights(z, data.edge_index)
+            edge_weight_loss = edge_weight_reconstruction_loss(pred_edge_weights, data.edge_attr)
+            loss = (loss_weight_node * node_loss) + (loss_weight_edge * edge_loss) + (loss_weight_edge_attr * edge_weight_loss)
+            print(f"node_loss: {node_loss}, edge_loss: {edge_loss:.4f}, edge_weight_loss: {edge_weight_loss:.4f}, cosine_similarity: {cos_sim:.4f}")
+            loss.backward()
+            self.optimizer.step()
+            total_loss += loss.item()
+
+        avg_loss, avg_cosine_similarity = total_loss / len(data_loader), total_cosine_similarity / len(data_loader)
+        return avg_loss, avg_cosine_similarity
+
+    def fit(self, train_loader, validation_loader, epochs, device):
+        train_losses = []
+        val_losses = []
+
+        for epoch in range(1, epochs + 1):
+            train_loss, train_cosine_similarity = self.train_model(train_loader, device)
+            torch.cuda.empty_cache()
+            val_loss, val_cosine_similarity = self.validate(validation_loader, device)
+            print(f"Epoch: {epoch}, Train Loss: {train_loss:.4f}, Train Cosine Similarity: {train_cosine_similarity:.4f}, Validation Loss: {val_loss:.4f}, Validation Cosine Similarity: {val_cosine_similarity:.4f}")
+            self.scheduler.step()
+
+        return train_losses, val_losses
+
+    def validate(self, validation_loader, device):
+        self.encoder.to(device)
+        self.decoder.to(device)
+        self.encoder.eval()
+        self.decoder.eval()
+        total_loss = 0
+        total_cosine_similarity = 0
+
+        with torch.no_grad():
+            for data in validation_loader:
+                data = data.to(device)
+                z, attention_weights = self.encoder(data.x, data.edge_index, data.edge_attr)
+                x_reconstructed = self.decoder(z)
+                node_loss = graph_reconstruction_loss(x_reconstructed, data.x)
+                edge_loss = edge_reconstruction_loss(z, data.edge_index)
+                cos_sim = cosine_similarity(x_reconstructed, data.x, dim=-1).mean()
+                total_cosine_similarity += cos_sim.item()
+                loss = node_loss + edge_loss
+                total_loss += loss.item()
+
+        avg_loss = total_loss / len(validation_loader)
+        avg_cosine_similarity = total_cosine_similarity / len(validation_loader)
+        return avg_loss, avg_cosine_similarity
+
+    def evaluate(self, test_loader, device):
+        self.encoder.to(device)
+        self.decoder.to(device)
+        self.encoder.eval()
+        self.decoder.eval()
+        total_loss = 0
+        total_accuracy = 0
+
+        with torch.no_grad():
+            for data in test_loader:
+                data = data.to(device)
+                z, attention_weights = self.encoder(data.x, data.edge_index, data.edge_attr)
+                x_reconstructed = self.decoder(z)
+                node_loss = graph_reconstruction_loss(x_reconstructed, data.x)
+                edge_loss = edge_reconstruction_loss(z, data.edge_index)
+                cos_sim = cosine_similarity(x_reconstructed, data.x, dim=-1).mean()
+                total_cosine_similarity += cos_sim.item()
+                loss = node_loss + edge_loss
+                total_loss += loss.item()
+                
+        avg_loss = total_loss / len(validation_loader)
+        avg_cosine_similarity = total_cosine_similarity / len(validation_loader)
+        return avg_loss, avg_cosine_similarity
+
+# Define a collate function for the DataLoader
+def collate_graph_data(batch):
+    return Batch.from_data_list(batch)
+
+# Define a function to create a DataLoader
+def create_data_loader(train_data, batch_size=1, shuffle=True):
+    graph_data = list(train_data.values())
+    return DataLoader(graph_data, batch_size=batch_size, shuffle=shuffle, collate_fn=collate_graph_data)
+
+# Define functions for the losses
+def graph_reconstruction_loss(pred_features, true_features):
+    return F.mse_loss(pred_features, true_features)
+
+def edge_reconstruction_loss(z, pos_edge_index, neg_edge_index=None):
+    pos_logits = (z[pos_edge_index[0]] * z[pos_edge_index[1]]).sum(dim=-1)
+    pos_loss = F.binary_cross_entropy_with_logits(pos_logits, torch.ones_like(pos_logits))
+    if neg_edge_index is None:
+        neg_edge_index = negative_sampling(pos_edge_index, z.size(0))
+    neg_logits = (z[neg_edge_index[0]] * z[neg_edge_index[1]]).sum(dim=-1)
+    neg_loss = F.binary_cross_entropy_with_logits(neg_logits, torch.zeros_like(neg_logits))
+    return pos_loss + neg_loss
+
+def edge_weight_reconstruction_loss(pred_weights, true_weights):
+    pred_weights = pred_weights.squeeze(-1)
+    return F.mse_loss(pred_weights, true_weights)

OmicsConfig.py

@@ -0,0 +1,27 @@
+from transformers import PretrainedConfig
+from transformers import PretrainedConfig, PreTrainedModel
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torch_geometric.nn import GATv2Conv
+from torch_geometric.data import Batch
+from torch.utils.data import DataLoader
+from torch.optim import AdamW
+from torch_geometric.utils import negative_sampling
+from torch.nn.functional import cosine_similarity
+from torch.optim.lr_scheduler import StepLR
+
+
+class OmicsConfig(PretrainedConfig):
+    model_type = "omics-graph-network"
+
+    def __init__(self, in_channels=768, edge_attr_channels=128, out_channels=128, original_feature_size=768, learning_rate=0.01, num_layers=1, edge_decoder_hidden_sizes=[128], edge_decoder_activations=['ReLU'], **kwargs):
+        super().__init__(**kwargs)
+        self.in_channels = in_channels
+        self.edge_attr_channels = edge_attr_channels
+        self.out_channels = out_channels
+        self.original_feature_size = original_feature_size
+        self.learning_rate = learning_rate
+        self.num_layers = num_layers
+        self.edge_decoder_hidden_sizes = edge_decoder_hidden_sizes
+        self.edge_decoder_activations = edge_decoder_activations 

app.py

@@ -14,11 +14,6 @@ from lifelines.statistics import logrank_test
 import os
 import subprocess
 
-# Clone the GitHub repository
-if not os.path.exists('/workspace/MultiOmics-Graph-Attention-Autoencoder'):
-    subprocess.run(['git', 'clone', 'https://github.com/VatsalPatel18/MultiOmics-Graph-Attention-Autoencoder.git', '/workspace/MultiOmics-Graph-Attention-Autoencoder'])
-    subprocess.run(['git', 'clone', 'https://huggingface.co/VatsalPatel18/HNSCC-MultiOmics-Graph-Attention-Autoencoder', '/workspace/HNSCC-MultiOmics-Graph-Attention-Autoencoder'])
-
 from MultiOmicsGraphAttentionAutoencoderModel import MultiOmicsGraphAttentionAutoencoderModel
 from OmicsConfig import OmicsConfig
 from Attention_Extracter import Attention_Extracter

data/README.md

@@ -0,0 +1 @@
+Data Here

data/survival.hnsc_data.csv

@@ -0,0 +1,524 @@
+PatientID,Overall Survival Status,Overall Survival (Months)
+TCGA-4P-AA8J-01,0,3.353387908
+TCGA-BA-4074-01,1,15.18887464
+TCGA-BA-4076-01,1,13.6436861
+TCGA-BA-4078-01,1,9.073873163
+TCGA-BA-5149-01,1,26.49833974
+TCGA-BA-5151-01,0,23.73672617
+TCGA-BA-5152-01,0,42.34474143
+TCGA-BA-5153-01,1,57.92813229
+TCGA-BA-5555-01,0,17.09570306
+TCGA-BA-5556-01,0,23.83535523
+TCGA-BA-5557-01,0,20.48196732
+TCGA-BA-5558-01,0,65.58832232
+TCGA-BA-5559-01,1,68.4814413
+TCGA-BA-6868-01,1,15.51763816
+TCGA-BA-6869-01,0,21.17237071
+TCGA-BA-6870-01,1,14.82723477
+TCGA-BA-6871-01,1,3.55064602
+TCGA-BA-6872-01,1,12.62451918
+TCGA-BA-6873-01,0,4.010914949
+TCGA-BA-7269-01,0,41.85159615
+TCGA-BA-A4IF-01,0,29.42433508
+TCGA-BA-A4IG-01,0,28.10928099
+TCGA-BA-A4IH-01,0,20.44909097
+TCGA-BA-A4II-01,0,30.18049117
+TCGA-BA-A6D8-01,0,27.94489923
+TCGA-BA-A6DA-01,0,11.53959957
+TCGA-BA-A6DB-01,0,7.101292041
+TCGA-BA-A6DD-01,1,5.687608903
+TCGA-BA-A6DE-01,0,14.4655949
+TCGA-BA-A6DF-01,1,7.824571786
+TCGA-BA-A6DG-01,1,2.268468291
+TCGA-BA-A6DI-01,1,11.04645429
+TCGA-BA-A6DJ-01,1,13.38067528
+TCGA-BA-A6DL-01,0,20.48196732
+TCGA-BA-A8YP-01,0,16.40529967
+TCGA-BB-4217-01,0,6.147877832
+TCGA-BB-4223-01,0,105.8947299
+TCGA-BB-4224-01,0,9.139625867
+TCGA-BB-4225-01,0,4.799947398
+TCGA-BB-4227-01,0,4.405431173
+TCGA-BB-4228-01,0,18.37788079
+TCGA-BB-7861-01,0,22.42167209
+TCGA-BB-7862-01,0,36.72288523
+TCGA-BB-7863-01,0,33.69826084
+TCGA-BB-7864-01,0,50.20218957
+TCGA-BB-7866-01,0,44.97484959
+TCGA-BB-7870-01,0,66.27872571
+TCGA-BB-7871-01,0,24.65726403
+TCGA-BB-7872-01,0,38.39957918
+TCGA-BB-8596-01,0,71.04579676
+TCGA-BB-8601-01,0,20.51484367
+TCGA-BB-A5HU-01,0,25.7093073
+TCGA-BB-A5HY-01,1,10.55330901
+TCGA-BB-A5HZ-01,0,27.18874314
+TCGA-BB-A6UM-01,0,12.92040635
+TCGA-BB-A6UO-01,1,8.810862347
+TCGA-C9-A47Z-01,1,6.27938324
+TCGA-C9-A480-01,0,12.69027189
+TCGA-CN-4722-01,0,48.75563008
+TCGA-CN-4723-01,0,55.85692212
+TCGA-CN-4725-01,0,38.03793931
+TCGA-CN-4726-01,1,4.66844199
+TCGA-CN-4727-01,0,51.28710918
+TCGA-CN-4728-01,0,56.67883092
+TCGA-CN-4729-01,0,12.88753
+TCGA-CN-4730-01,0,26.85997962
+TCGA-CN-4731-01,1,32.81059934
+TCGA-CN-4733-01,0,52.14189434
+TCGA-CN-4734-01,0,55.56103495
+TCGA-CN-4735-01,0,57.10622349
+TCGA-CN-4736-01,1,12.98615906
+TCGA-CN-4737-01,0,20.54772003
+TCGA-CN-4738-01,1,14.33408949
+TCGA-CN-4739-01,1,45.82963474
+TCGA-CN-4740-01,1,27.58325936
+TCGA-CN-4741-01,0,73.61015222
+TCGA-CN-4742-01,1,13.05191176
+TCGA-CN-5355-01,0,42.01597791
+TCGA-CN-5356-01,0,46.32278002
+TCGA-CN-5358-01,1,8.580727882
+TCGA-CN-5359-01,1,12.39438472
+TCGA-CN-5360-01,0,71.30880758
+TCGA-CN-5361-01,1,69.69786633
+TCGA-CN-5363-01,1,8.317717066
+TCGA-CN-5364-01,1,16.20804156
+TCGA-CN-5365-01,1,11.53959957
+TCGA-CN-5366-01,1,11.83548673
+TCGA-CN-5367-01,1,11.57247592
+TCGA-CN-5369-01,1,12.49301378
+TCGA-CN-5370-01,1,8.514975178
+TCGA-CN-5373-01,0,52.07614163
+TCGA-CN-5374-01,1,56.94184173
+TCGA-CN-6010-01,0,50.07068416
+TCGA-CN-6011-01,0,30.67363645
+TCGA-CN-6012-01,0,47.99947398
+TCGA-CN-6013-01,1,23.90110793
+TCGA-CN-6016-01,0,47.44057599
+TCGA-CN-6017-01,1,28.04352829
+TCGA-CN-6018-01,1,19.06828418
+TCGA-CN-6019-01,0,34.12565342
+TCGA-CN-6020-01,1,6.739652168
+TCGA-CN-6021-01,1,9.073873163
+TCGA-CN-6022-01,1,9.238254923
+TCGA-CN-6023-01,0,52.07614163
+TCGA-CN-6024-01,1,11.07933064
+TCGA-CN-6988-01,0,10.45467995
+TCGA-CN-6989-01,1,32.218825
+TCGA-CN-6992-01,0,35.04619128
+TCGA-CN-6994-01,0,38.89272446
+TCGA-CN-6995-01,1,3.682151429
+TCGA-CN-6996-01,1,17.42446658
+TCGA-CN-6997-01,1,32.48183582
+TCGA-CN-6998-01,1,11.73685768
+TCGA-CN-A497-01,0,35.01331492
+TCGA-CN-A498-01,1,25.41342013
+TCGA-CN-A499-01,0,23.57234441
+TCGA-CN-A49A-01,1,17.29296117
+TCGA-CN-A49B-01,0,29.72022224
+TCGA-CN-A49C-01,0,21.20524707
+TCGA-CN-A63T-01,0,7.397179209
+TCGA-CN-A63U-01,0,31.69280337
+TCGA-CN-A63V-01,0,22.32304304
+TCGA-CN-A63W-01,1,12.39438472
+TCGA-CN-A63Y-01,0,16.56968143
+TCGA-CN-A640-01,1,4.405431173
+TCGA-CN-A641-01,0,12.0656212
+TCGA-CN-A642-01,1,2.695860867
+TCGA-CN-A6UY-01,0,23.44083901
+TCGA-CN-A6V1-01,0,19.82444028
+TCGA-CN-A6V3-01,0,24.39425321
+TCGA-CN-A6V6-01,0,20.87648355
+TCGA-CN-A6V7-01,0,19.52855311
+TCGA-CQ-5323-01,0,48.19673209
+TCGA-CQ-5324-01,0,52.3720288
+TCGA-CQ-5325-01,1,21.50113423
+TCGA-CQ-5326-01,1,2.925995332
+TCGA-CQ-5327-01,0,54.57474439
+TCGA-CQ-5329-01,0,70.45402242
+TCGA-CQ-5330-01,0,62.36643982
+TCGA-CQ-5331-01,0,45.9940165
+TCGA-CQ-5332-01,1,10.4218036
+TCGA-CQ-5333-01,1,11.21083605
+TCGA-CQ-5334-01,1,4.241049413
+TCGA-CQ-6218-01,0,41.19406911
+TCGA-CQ-6219-01,1,15.74777263
+TCGA-CQ-6220-01,1,32.38320676
+TCGA-CQ-6222-01,0,66.27872571
+TCGA-CQ-6223-01,0,46.94743071
+TCGA-CQ-6224-01,0,56.58020186
+TCGA-CQ-6225-01,1,13.24916987
+TCGA-CQ-6227-01,1,4.241049413
+TCGA-CQ-6228-01,1,14.99161653
+TCGA-CQ-6229-01,0,38.76121906
+TCGA-CQ-7063-01,0,70.1252589
+TCGA-CQ-7064-01,0,64.86504258
+TCGA-CQ-7065-01,0,53.52270112
+TCGA-CQ-7067-01,0,16.73406319
+TCGA-CQ-7068-01,0,43.03514482
+TCGA-CQ-7069-01,0,41.8844725
+TCGA-CQ-7071-01,0,43.10089752
+TCGA-CQ-7072-01,0,77.55531446
+TCGA-CQ-A4C6-01,0,44.48170431
+TCGA-CQ-A4C9-01,0,23.24358089
+TCGA-CQ-A4CA-01,0,
+TCGA-CQ-A4CB-01,0,29.35858237
+TCGA-CQ-A4CD-01,0,33.59963179
+TCGA-CQ-A4CE-01,0,29.49008778
+TCGA-CQ-A4CG-01,1,14.13683138
+TCGA-CQ-A4CH-01,1,12.46013742
+TCGA-CQ-A4CI-01,0,31.23253444
+TCGA-CR-5243-01,0,84.22921393
+TCGA-CR-5247-01,0,11.76973403
+TCGA-CR-5248-01,0,54.67337344
+TCGA-CR-5249-01,0,37.87355755
+TCGA-CR-5250-01,0,26.26820528
+TCGA-CR-6467-01,0,58.42127758
+TCGA-CR-6470-01,0,50.00493145
+TCGA-CR-6471-01,1,39.51737515
+TCGA-CR-6472-01,0,34.52016964
+TCGA-CR-6473-01,0,36.98589605
+TCGA-CR-6474-01,1,18.54226255
+TCGA-CR-6477-01,0,16.89844495
+TCGA-CR-6478-01,1,6.016372423
+TCGA-CR-6480-01,0,11.90123944
+TCGA-CR-6481-01,0,10.22454548
+TCGA-CR-6482-01,0,11.34234145
+TCGA-CR-6484-01,0,11.63822862
+TCGA-CR-6487-01,0,7.693066377
+TCGA-CR-6488-01,0,12.46013742
+TCGA-CR-6491-01,0,22.78331196
+TCGA-CR-6492-01,0,15.74777263
+TCGA-CR-6493-01,1,9.271131275
+TCGA-CR-7364-01,0,47.17756518
+TCGA-CR-7365-01,0,39.15573528
+TCGA-CR-7367-01,0,47.34194694
+TCGA-CR-7368-01,0,40.93105829
+TCGA-CR-7369-01,1,35.83522372
+TCGA-CR-7370-01,0,3.452016964
+TCGA-CR-7371-01,1,3.090377092
+TCGA-CR-7372-01,0,24.9531512
+TCGA-CR-7373-01,0,29.22707696
+TCGA-CR-7374-01,0,0.986290561
+TCGA-CR-7376-01,0,31.95581418
+TCGA-CR-7377-01,1,9.172502219
+TCGA-CR-7379-01,0,34.05990071
+TCGA-CR-7380-01,1,19.92306934
+TCGA-CR-7382-01,0,26.16957622
+TCGA-CR-7383-01,1,17.12857941
+TCGA-CR-7385-01,0,32.77772298
+TCGA-CR-7386-01,0,47.01318342
+TCGA-CR-7388-01,1,27.05723773
+TCGA-CR-7389-01,0,12.88753
+TCGA-CR-7390-01,0,49.57753888
+TCGA-CR-7391-01,0,30.01610941
+TCGA-CR-7392-01,0,46.84880166
+TCGA-CR-7393-01,0,32.64621758
+TCGA-CR-7394-01,0,44.25156985
+TCGA-CR-7395-01,0,30.5750074
+TCGA-CR-7397-01,0,24.78876944
+TCGA-CR-7398-01,0,5.128710918
+TCGA-CR-7399-01,0,5.950619719
+TCGA-CR-7401-01,0,35.40783115
+TCGA-CR-7402-01,0,29.95035671
+TCGA-CR-7404-01,0,48.3939902
+TCGA-CV-5430-01,0,139.428609
+TCGA-CV-5431-01,1,17.16145577
+TCGA-CV-5432-01,0,129.2040635
+TCGA-CV-5434-01,1,108.9522307
+TCGA-CV-5435-01,1,76.24026038
+TCGA-CV-5436-01,1,19.19978959
+TCGA-CV-5439-01,1,17.95048821
+TCGA-CV-5440-01,0,107.5056712
+TCGA-CV-5441-01,0,94.88115199
+TCGA-CV-5442-01,0,76.5032712
+TCGA-CV-5443-01,0,91.52776408
+TCGA-CV-5444-01,0,80.11966992
+TCGA-CV-5966-01,1,17.91761186
+TCGA-CV-5970-01,1,13.34779893
+TCGA-CV-5971-01,0,23.04632278
+TCGA-CV-5973-01,0,86.82644574
+TCGA-CV-5976-01,0,48.59124832
+TCGA-CV-5977-01,0,60.49248775
+TCGA-CV-5978-01,1,7.068415689
+TCGA-CV-5979-01,0,43.23240293
+TCGA-CV-6003-01,0,54.73912615
+TCGA-CV-6433-01,0,21.07374166
+TCGA-CV-6436-01,0,62.43219252
+TCGA-CV-6441-01,1,9.599894796
+TCGA-CV-6933-01,1,90.11408094
+TCGA-CV-6934-01,1,2.136962883
+TCGA-CV-6935-01,1,9.698523852
+TCGA-CV-6936-01,1,5.457474439
+TCGA-CV-6937-01,1,20.51484367
+TCGA-CV-6938-01,1,4.734194694
+TCGA-CV-6939-01,1,21.89565046
+TCGA-CV-6940-01,1,26.43258704
+TCGA-CV-6941-01,1,11.2437124
+TCGA-CV-6942-01,0,140.7765394
+TCGA-CV-6943-01,1,19.79156393
+TCGA-CV-6945-01,1,12.03274485
+TCGA-CV-6948-01,1,42.37761778
+TCGA-CV-6950-01,1,15.09024559
+TCGA-CV-6951-01,1,30.08186212
+TCGA-CV-6952-01,1,6.082125127
+TCGA-CV-6953-01,1,53.9500937
+TCGA-CV-6954-01,1,65.81845678
+TCGA-CV-6955-01,1,10.98070158
+TCGA-CV-6956-01,1,7.134168393
+TCGA-CV-6959-01,1,8.416346122
+TCGA-CV-6960-01,1,28.33941546
+TCGA-CV-6961-01,1,2.498602755
+TCGA-CV-6962-01,1,4.142420357
+TCGA-CV-7089-01,1,64.83216622
+TCGA-CV-7090-01,0,172.6666009
+TCGA-CV-7091-01,0,111.1549463
+TCGA-CV-7095-01,1,18.80527337
+TCGA-CV-7097-01,1,12.65739554
+TCGA-CV-7099-01,1,7.988953546
+TCGA-CV-7100-01,1,9.008120459
+TCGA-CV-7101-01,1,5.260216326
+TCGA-CV-7102-01,1,1.841075714
+TCGA-CV-7103-01,1,52.3062761
+TCGA-CV-7104-01,1,12.92040635
+TCGA-CV-7177-01,1,21.7970214
+TCGA-CV-7178-01,1,71.21017852
+TCGA-CV-7180-01,1,10.75056712
+TCGA-CV-7183-01,0,130.8807575
+TCGA-CV-7235-01,0,77.16079824
+TCGA-CV-7236-01,1,4.734194694
+TCGA-CV-7238-01,0,89.65381201
+TCGA-CV-7242-01,0,35.99960548
+TCGA-CV-7243-01,0,31.36403985
+TCGA-CV-7245-01,0,26.20245258
+TCGA-CV-7247-01,1,18.96965513
+TCGA-CV-7248-01,1,17.12857941
+TCGA-CV-7250-01,1,95.34142092
+TCGA-CV-7252-01,1,4.964329158
+TCGA-CV-7253-01,1,11.86836309
+TCGA-CV-7254-01,1,47.96659763
+TCGA-CV-7255-01,1,2.104086531
+TCGA-CV-7261-01,0,49.70904428
+TCGA-CV-7263-01,1,18.41075714
+TCGA-CV-7406-01,1,57.46786337
+TCGA-CV-7407-01,1,35.53933656
+TCGA-CV-7409-01,1,17.85185916
+TCGA-CV-7410-01,1,210.967551
+TCGA-CV-7411-01,1,89.32504849
+TCGA-CV-7413-01,1,9.6656475
+TCGA-CV-7414-01,1,0.460268929
+TCGA-CV-7415-01,1,22.84906467
+TCGA-CV-7416-01,1,25.08465661
+TCGA-CV-7418-01,1,25.93944176
+TCGA-CV-7421-01,1,0.065752704
+TCGA-CV-7422-01,1,34.09277707
+TCGA-CV-7423-01,1,100.5687609
+TCGA-CV-7424-01,1,14.89298747
+TCGA-CV-7425-01,1,56.48157281
+TCGA-CV-7427-01,1,156.4914357
+TCGA-CV-7428-01,1,54.93638426
+TCGA-CV-7429-01,1,3.517769668
+TCGA-CV-7430-01,1,16.27379426
+TCGA-CV-7432-01,1,84.49222474
+TCGA-CV-7433-01,1,19.75868758
+TCGA-CV-7434-01,1,7.167044745
+TCGA-CV-7435-01,1,153.8613276
+TCGA-CV-7437-01,1,16.63543413
+TCGA-CV-7438-01,1,6.378012296
+TCGA-CV-7440-01,1,22.19153763
+TCGA-CV-7446-01,1,35.93385278
+TCGA-CV-7568-01,1,30.47637834
+TCGA-CV-A45O-01,0,27.97777559
+TCGA-CV-A45P-01,0,21.00798895
+TCGA-CV-A45Q-01,1,169.3789657
+TCGA-CV-A45R-01,0,180.1624092
+TCGA-CV-A45T-01,1,159.6475655
+TCGA-CV-A45U-01,1,35.47358385
+TCGA-CV-A45V-01,1,1.052043265
+TCGA-CV-A45W-01,1,45.96114015
+TCGA-CV-A45X-01,1,6.509517704
+TCGA-CV-A45Y-01,1,88.86477956
+TCGA-CV-A45Z-01,1,48.19673209
+TCGA-CV-A460-01,1,60.42673505
+TCGA-CV-A461-01,1,67.85679061
+TCGA-CV-A463-01,1,0.756156097
+TCGA-CV-A464-01,0,56.61307821
+TCGA-CV-A465-01,1,7.068415689
+TCGA-CV-A468-01,1,15.25462735
+TCGA-CV-A6JD-01,1,5.983496071
+TCGA-CV-A6JE-01,0,35.34207844
+TCGA-CV-A6JM-01,1,6.378012296
+TCGA-CV-A6JN-01,0,29.78597495
+TCGA-CV-A6JO-01,1,6.476641352
+TCGA-CV-A6JT-01,0,28.01065194
+TCGA-CV-A6JU-01,0,3.616398724
+TCGA-CV-A6JY-01,0,21.23812342
+TCGA-CV-A6JZ-01,0,23.47371536
+TCGA-CV-A6K0-01,0,19.92306934
+TCGA-CV-A6K1-01,0,22.52030115
+TCGA-CV-A6K2-01,1,10.4218036
+TCGA-CX-7085-01,0,10.55330901
+TCGA-CX-7086-01,0,18.83814972
+TCGA-CX-7219-01,0,34.35578788
+TCGA-CX-A4AQ-01,0,51.12272742
+TCGA-D6-6515-01,1,13.24916987
+TCGA-D6-6516-01,0,25.41342013
+TCGA-D6-6517-01,0,9.599894796
+TCGA-D6-6823-01,0,23.04632278
+TCGA-D6-6824-01,0,2.531479107
+TCGA-D6-6825-01,0,16.14228885
+TCGA-D6-6826-01,1,11.44097051
+TCGA-D6-6827-01,0,18.67376796
+TCGA-D6-8568-01,0,24.9531512
+TCGA-D6-8569-01,0,25.31479107
+TCGA-D6-A4Z9-01,0,17.72035375
+TCGA-D6-A4ZB-01,0,12.36150837
+TCGA-D6-A6EK-01,0,28.76680804
+TCGA-D6-A6EM-01,0,7.627313673
+TCGA-D6-A6EN-01,0,22.58605385
+TCGA-D6-A6EO-01,0,24.9531512
+TCGA-D6-A6EP-01,0,13.93957327
+TCGA-D6-A6EQ-01,0,12.09849755
+TCGA-D6-A6ES-01,0,12.78890094
+TCGA-D6-A74Q-01,0,23.34220995
+TCGA-DQ-5624-01,0,58.45415393
+TCGA-DQ-5625-01,1,37.24890686
+TCGA-DQ-5629-01,1,30.93664727
+TCGA-DQ-5630-01,0,33.8626426
+TCGA-DQ-5631-01,1,18.01624092
+TCGA-DQ-7588-01,1,14.03820232
+TCGA-DQ-7589-01,0,46.32278002
+TCGA-DQ-7590-01,0,46.45428543
+TCGA-DQ-7591-01,0,20.44909097
+TCGA-DQ-7592-01,0,37.57767038
+TCGA-DQ-7593-01,0,40.2406549
+TCGA-DQ-7594-01,0,40.04339679
+TCGA-DQ-7595-01,0,39.12285893
+TCGA-DQ-7596-01,0,41.58858533
+TCGA-F7-7848-01,0,37.18315416
+TCGA-F7-8298-01,0,32.71197028
+TCGA-F7-8489-01,0,21.63263964
+TCGA-F7-A50G-01,0,20.25183286
+TCGA-F7-A50I-01,0,3.024624388
+TCGA-F7-A50J-01,0,31.13390538
+TCGA-F7-A61S-01,0,18.93677878
+TCGA-F7-A61V-01,0,24.9531512
+TCGA-F7-A61W-01,0,0.460268929
+TCGA-F7-A620-01,0,17.85185916
+TCGA-F7-A622-01,1,11.80261038
+TCGA-F7-A623-01,0,20.25183286
+TCGA-F7-A624-01,0,12.42726107
+TCGA-H7-7774-01,0,13.38067528
+TCGA-H7-8501-01,0,15.15599829
+TCGA-H7-8502-01,0,15.05736923
+TCGA-H7-A6C4-01,0,13.61080975
+TCGA-H7-A6C5-01,0,21.10661801
+TCGA-H7-A76A-01,0,20.94223625
+TCGA-HD-7229-01,0,33.76401355
+TCGA-HD-7753-01,0,28.47092087
+TCGA-HD-7754-01,0,25.74218365
+TCGA-HD-7831-01,0,21.92852681
+TCGA-HD-7832-01,0,27.48463031
+TCGA-HD-7917-01,1,27.48463031
+TCGA-HD-8224-01,1,14.66285301
+TCGA-HD-8314-01,0,22.02715587
+TCGA-HD-8634-01,1,12.65739554
+TCGA-HD-8635-01,0,22.84906467
+TCGA-HD-A4C1-01,0,0.361639872
+TCGA-HD-A633-01,0,13.84094421
+TCGA-HD-A634-01,1,4.273925765
+TCGA-HD-A6HZ-01,0,3.649275076
+TCGA-HD-A6I0-01,0,6.904033928
+TCGA-HL-7533-01,0,34.75030411
+TCGA-IQ-7630-01,0,15.94503074
+TCGA-IQ-7631-01,0,38.53108459
+TCGA-IQ-7632-01,0,14.49847125
+TCGA-IQ-A61E-01,0,37.70917579
+TCGA-IQ-A61G-01,0,11.83548673
+TCGA-IQ-A61H-01,0,37.41328862
+TCGA-IQ-A61I-01,1,0.065752704
+TCGA-IQ-A61J-01,0,33.56675543
+TCGA-IQ-A61K-01,1,5.293092678
+TCGA-IQ-A61L-01,0,13.67656245
+TCGA-IQ-A61O-01,1,13.84094421
+TCGA-IQ-A6SG-01,0,19.03540783
+TCGA-IQ-A6SH-01,0,15.48476181
+TCGA-KU-A66S-01,1,13.34779893
+TCGA-KU-A66T-01,0,18.14774633
+TCGA-KU-A6H7-01,0,19.2655423
+TCGA-KU-A6H8-01,1,10.75056712
+TCGA-MT-A51W-01,0,14.36696584
+TCGA-MT-A51X-01,0,7.956077194
+TCGA-MT-A67A-01,0,30.04898577
+TCGA-MT-A67D-01,0,1.841075714
+TCGA-MT-A67F-01,0,12.62451918
+TCGA-MT-A67G-01,0,6.246506888
+TCGA-MT-A7BN-01,0,15.41900911
+TCGA-MZ-A5BI-01,1,7.134168393
+TCGA-MZ-A6I9-01,1,16.07653615
+TCGA-MZ-A7D7-01,0,17.98336457
+TCGA-P3-A5Q5-01,0,29.91748036
+TCGA-P3-A5Q6-01,1,15.78064898
+TCGA-P3-A5QA-01,0,71.73620015
+TCGA-P3-A5QE-01,0,51.25423283
+TCGA-P3-A5QF-01,1,10.84919617
+TCGA-P3-A6SW-01,0,36.82151429
+TCGA-P3-A6SX-01,1,47.01318342
+TCGA-P3-A6T0-01,0,19.00253148
+TCGA-P3-A6T2-01,0,75.54985699
+TCGA-P3-A6T3-01,1,18.96965513
+TCGA-P3-A6T4-01,1,2.038333827
+TCGA-P3-A6T5-01,1,28.9969425
+TCGA-P3-A6T6-01,1,12.98615906
+TCGA-P3-A6T7-01,1,16.01078344
+TCGA-P3-A6T8-01,0,13.15054082
+TCGA-QK-A64Z-01,1,21.07374166
+TCGA-QK-A652-01,0,21.20524707
+TCGA-QK-A6IF-01,0,23.14495184
+TCGA-QK-A6IG-01,1,7.298550153
+TCGA-QK-A6IH-01,0,21.46825788
+TCGA-QK-A6II-01,1,9.336883979
+TCGA-QK-A6IJ-01,0,12.72314824
+TCGA-QK-A6V9-01,0,27.38600125
+TCGA-QK-A6VB-01,0,21.07374166
+TCGA-QK-A6VC-01,0,19.72581122
+TCGA-QK-A8Z7-01,0,12.88753
+TCGA-QK-A8Z8-01,1,5.621856199
+TCGA-QK-A8Z9-01,1,14.76148207
+TCGA-QK-A8ZA-01,1,12.19712661
+TCGA-QK-A8ZB-01,0,17.81898281
+TCGA-QK-AA3J-01,0,15.32038005
+TCGA-QK-AA3K-01,0,8.317717066
+TCGA-RS-A6TO-01,1,12.72314824
+TCGA-RS-A6TP-01,0,16.96419765
+TCGA-T2-A6WX-01,1,6.871157576
+TCGA-T2-A6WZ-01,1,15.91215439
+TCGA-T2-A6X0-01,0,7.101292041
+TCGA-T2-A6X2-01,0,32.44895946
+TCGA-T3-A92M-01,0,13.7094388
+TCGA-T3-A92N-01,1,3.123253444
+TCGA-TN-A7HI-01,0,13.54505704
+TCGA-TN-A7HJ-01,0,13.24916987
+TCGA-TN-A7HL-01,0,20.35046191
+TCGA-UF-A718-01,0,64.79928987
+TCGA-UF-A719-01,0,54.67337344
+TCGA-UF-A71A-01,1,2.827366275
+TCGA-UF-A71B-01,0,49.51178617
+TCGA-UF-A71D-01,0,48.03235033
+TCGA-UF-A71E-01,1,49.44603347
+TCGA-UF-A7J9-01,0,44.64608607
+TCGA-UF-A7JA-01,0,74.46493737
+TCGA-UF-A7JC-01,1,17.95048821
+TCGA-UF-A7JD-01,1,24.29562416
+TCGA-UF-A7JF-01,0,55.42952954
+TCGA-UF-A7JH-01,0,29.45721143
+TCGA-UF-A7JJ-01,0,18.04911727
+TCGA-UF-A7JK-01,1,13.93957327
+TCGA-UF-A7JO-01,1,20.74497814
+TCGA-UF-A7JS-01,1,22.35591939
+TCGA-UF-A7JT-01,1,32.64621758
+TCGA-UF-A7JV-01,1,2.958871684
+TCGA-UP-A6WW-01,0,17.02995036
+TCGA-WA-A7GZ-01,1,20.54772003
+TCGA-WA-A7H4-01,0,14.56422395

lc_models/MultiOmicsAutoencoder/trained_autoencoder/config.json

@@ -0,0 +1,22 @@
+{
+  "architectures": [
+    "MultiOmicsGraphAttentionAutoencoderModel"
+  ],
+  "edge_attr_channels": 1,
+  "edge_decoder_activations": [
+    "ReLU",
+    "ReLU"
+  ],
+  "edge_decoder_hidden_sizes": [
+    128,
+    64
+  ],
+  "in_channels": 17,
+  "learning_rate": 0.01,
+  "model_type": "omics-graph-network",
+  "num_layers": 2,
+  "original_feature_size": 17,
+  "out_channels": 1,
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1"
+}

lc_models/MultiOmicsAutoencoder/trained_autoencoder/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9651f8c59ac5c0c57494a6553c92a14d78427ea6bbd0e2474132b1eea6b4ec87
+size 43263

lc_models/MultiOmicsAutoencoder/trained_decoder/config.json

@@ -0,0 +1,22 @@
+{
+  "architectures": [
+    "GATv2DecoderModel"
+  ],
+  "edge_attr_channels": 1,
+  "edge_decoder_activations": [
+    "ReLU",
+    "ReLU"
+  ],
+  "edge_decoder_hidden_sizes": [
+    128,
+    64
+  ],
+  "in_channels": 17,
+  "learning_rate": 0.01,
+  "model_type": "omics-graph-network",
+  "num_layers": 2,
+  "original_feature_size": 17,
+  "out_channels": 1,
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1"
+}

lc_models/MultiOmicsAutoencoder/trained_decoder/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3c49a50b01c9f04d3ec0cfd756e14d982e619911b86e1bb96d056dee541982f5
+size 38933

lc_models/MultiOmicsAutoencoder/trained_edge_weight_predictor/config.json

@@ -0,0 +1,22 @@
+{
+  "architectures": [
+    "EdgeWeightPredictorModel"
+  ],
+  "edge_attr_channels": 1,
+  "edge_decoder_activations": [
+    "ReLU",
+    "ReLU"
+  ],
+  "edge_decoder_hidden_sizes": [
+    128,
+    64
+  ],
+  "in_channels": 17,
+  "learning_rate": 0.01,
+  "model_type": "omics-graph-network",
+  "num_layers": 2,
+  "original_feature_size": 17,
+  "out_channels": 1,
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1"
+}

lc_models/MultiOmicsAutoencoder/trained_edge_weight_predictor/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93767ffe12d84ff9af955d7704c638317aafa046c58ad06e09a846513fd18f1b
+size 36999

lc_models/MultiOmicsAutoencoder/trained_encoder/config.json

@@ -0,0 +1,22 @@
+{
+  "architectures": [
+    "GATv2EncoderModel"
+  ],
+  "edge_attr_channels": 1,
+  "edge_decoder_activations": [
+    "ReLU",
+    "ReLU"
+  ],
+  "edge_decoder_hidden_sizes": [
+    128,
+    64
+  ],
+  "in_channels": 17,
+  "learning_rate": 0.01,
+  "model_type": "omics-graph-network",
+  "num_layers": 2,
+  "original_feature_size": 17,
+  "out_channels": 1,
+  "torch_dtype": "float32",
+  "transformers_version": "4.32.1"
+}

lc_models/MultiOmicsAutoencoder/trained_encoder/pytorch_model.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:73804072e5ca45ce24a20496c86ee124569589a5efda620aa589843a5ad83966
+size 4571

train.py

@@ -0,0 +1,105 @@
+import torch
+from torch.utils.data import DataLoader
+from torch_geometric.data import Batch
+from sklearn.model_selection import train_test_split
+import pickle
+
+from OmicsConfig import OmicsConfig
+from MultiOmicsGraphAttentionAutoencoderModel import MultiOmicsGraphAttentionAutoencoderModel
+from GATv2EncoderModel import GATv2EncoderModel
+from GATv2DecoderModel import GATv2DecoderModel
+from EdgeWeightPredictorModel import EdgeWeightPredictorModel
+
+def collate_graph_data(batch):
+    return Batch.from_data_list(batch)
+
+def create_data_loader(graph_data_dict, batch_size=1, shuffle=True):
+    graph_data = list(graph_data_dict.values())
+    return DataLoader(graph_data, batch_size=batch_size, shuffle=shuffle, collate_fn=collate_graph_data)
+
+# Load your data
+graph_data_dict = torch.load('data/graph_data_dictN.pth')
+
+# Split the data
+train_data, temp_data = train_test_split(list(graph_data_dict.items()), train_size=0.6, random_state=42)
+val_data, test_data = train_test_split(temp_data, test_size=0.5, random_state=42)
+
+# Convert lists back into dictionaries
+train_data = dict(train_data)
+val_data = dict(val_data)
+test_data = dict(test_data)
+
+# Define the configuration for the model
+autoencoder_config = OmicsConfig(
+    in_channels=17,
+    edge_attr_channels=1,
+    out_channels=1,
+    original_feature_size=17,
+    learning_rate=0.01,
+    num_layers=2,
+    edge_decoder_hidden_sizes=[128, 64],
+    edge_decoder_activations=['ReLU', 'ReLU']
+)
+
+# Initialize the model
+autoencoder_model = MultiOmicsGraphAttentionAutoencoderModel(autoencoder_config)
+
+# Create data loaders
+train_loader = create_data_loader(train_data, batch_size=4, shuffle=True)
+val_loader = create_data_loader(val_data, batch_size=4, shuffle=False)
+test_loader = create_data_loader(test_data, batch_size=4, shuffle=False)
+
+# Define the device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+
+# Training process
+def train_autoencoder(autoencoder_model, train_loader, validation_loader, epochs, device):
+    autoencoder_model.to(device)
+    train_losses = []
+    val_losses = []
+
+    for epoch in range(epochs):
+        # Train
+        autoencoder_model.train()
+        train_loss, train_cosine_similarity = autoencoder_model.train_model(train_loader, device)
+        print(f"Epoch {epoch+1}/{epochs}, Train Loss: {train_loss:.4f}, Train Cosine Similarity: {train_cosine_similarity:.4f}")
+        train_losses.append(train_loss)
+
+        # Validate
+        autoencoder_model.eval()
+        val_loss, val_cosine_similarity = autoencoder_model.validate(validation_loader, device)
+        print(f"Epoch {epoch+1}/{epochs}, Validation Loss: {val_loss:.4f}, Validation Cosine Similarity: {val_cosine_similarity:.4f}")
+        val_losses.append(val_loss)
+
+    # Save the trained encoder weights
+    trained_encoder_path = "lc_models/MultiOmicsAutoencoder/trained_encoder"
+    autoencoder_model.encoder.save_pretrained(trained_encoder_path)
+
+    # Save the trained decoder weights
+    trained_decoder_path = "lc_models/MultiOmicsAutoencoder/trained_decoder"
+    autoencoder_model.decoder.save_pretrained(trained_decoder_path)
+
+    # Save the trained edge weight predictor weights (if needed separately)
+    trained_edge_weight_predictor_path = "lc_models/MultiOmicsAutoencoder/trained_edge_weight_predictor"
+    autoencoder_model.decoder.edge_weight_predictor.save_pretrained(trained_edge_weight_predictor_path)
+
+    # Optionally save the entire autoencoder again if you want to have a complete package
+    trained_autoencoder_path = "lc_models/MultiOmicsAutoencoder/trained_autoencoder"
+    autoencoder_model.save_pretrained(trained_autoencoder_path)
+
+    return train_losses, val_losses
+
+# Train and save the model
+train_losses, val_losses = train_autoencoder(autoencoder_model, train_loader, val_loader, epochs=10, device=device)
+
+# Evaluate the model
+test_loss, test_accuracy = autoencoder_model.evaluate(test_loader, device)
+print(f"Test Loss: {test_loss:.4f}")
+print(f"Test Accuracy: {test_accuracy:.4%}")
+
+# Save the training and validation losses
+with open('./results/train_loss.pkl', 'wb') as f:
+    pickle.dump(train_losses, f)
+
+with open('./results/val_loss.pkl', 'wb') as f:
+    pickle.dump(val_losses, f)