Upload 10 files

.Rhistory

@@ -0,0 +1,14 @@
+library(readr)
+# 读取数据
+mathylation <- read.csv("pca_principal_components.csv")
+data <- read_tsv("TCGA-ACC.survival.tsv", na = c("NaN", "null", ""))
+data <- read_tsv("TCGA-LGG.survival.tsv", na = c("NaN", "null", ""))
+data = data[data$OS == 1, ]
+# 更改列名
+colnames(mathylation)[1] = 'sample'
+# 合并数据
+data = merge(data, mathylation, by = 'sample')
+data = data[, -c(1, 2, 3)]
+data[is.na(data)] <- 0
+# 保存结果
+write.csv(data, 'data.csv')

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+webplot.png filter=lfs diff=lfs merge=lfs -text

PCA.py

@@ -0,0 +1,66 @@
+import pandas as pd
+from sklearn.decomposition import PCA
+from sklearn.preprocessing import StandardScaler
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+import os
+import joblib
+
+
+script_path = os.path.abspath(__file__)
+script_dir = os.path.dirname(script_path)
+os.chdir(script_dir)
+
+
+file_path = 'TCGA-LGG.methylation450.tsv'  
+df = pd.read_csv(file_path, sep='\t', index_col=0)
+
+
+
+df.dropna(inplace=True)
+
+
+scaler = StandardScaler()
+scaled_data = scaler.fit_transform(df.T)  
+
+
+pca = PCA(n_components=50)  
+principal_components = pca.fit_transform(scaled_data)
+
+
+pca_model_path = 'pca_model.pkl'
+joblib.dump(pca, pca_model_path)
+print(f"PCA模型已保存为 {pca_model_path}")
+
+
+loadings = pd.DataFrame(pca.components_.T, columns=[f'PC{i+1}' for i in range(pca.n_components_)], index=df.index)
+loadings.to_csv('pca_loadings.csv')
+print("主成分载荷矩阵已保存为 pca_loadings.csv")
+
+
+sample_ids = df.columns
+principal_df = pd.DataFrame(data=principal_components, columns=[f'Principal Component {i+1}' for i in range(50)], index=sample_ids)
+
+
+fig = plt.figure(figsize=(10, 8))
+ax = fig.add_subplot(111, projection='3d')
+ax.scatter(principal_df['Principal Component 1'], principal_df['Principal Component 2'], principal_df['Principal Component 3'])
+
+for i, sample_id in enumerate(sample_ids):
+    ax.text(principal_df['Principal Component 1'][i], principal_df['Principal Component 2'][i], principal_df['Principal Component 3'][i], sample_id)
+
+ax.set_xlabel('Principal Component 1')
+ax.set_ylabel('Principal Component 2')
+ax.set_zlabel('Principal Component 3')
+ax.set_title('3D PCA of Methylation Data')
+plt.show()
+
+
+output_file_path = 'pca_principal_components.csv'
+principal_df.to_csv(output_file_path)
+
+
+explained_variance = pca.explained_variance_ratio_
+print(f"Explained variance by each component: {explained_variance}")
+
+print(f"50个主成分已保存为 {output_file_path}")

Training_Data_Generation.R

@@ -0,0 +1,15 @@
+library(readr)
+
+mathylation <- read.csv("pca_principal_components.csv")
+
+data <- read_tsv("TCGA-LGG.survival.tsv", na = c("NaN", "null", ""))
+data = data[data$OS == 1, ]
+
+colnames(mathylation)[1] = 'sample'
+
+
+data = merge(data, mathylation, by = 'sample')
+data = data[, -c(1, 2, 3)]
+data[is.na(data)] <- 0
+
+write.csv(data, 'data.csv')

bar.py

@@ -0,0 +1,22 @@
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+
+script_path = os.path.abspath(__file__)
+script_dir = os.path.dirname(script_path)
+os.chdir(script_dir)
+
+
+cmap = plt.colormaps['viridis']
+
+
+fig, ax = plt.subplots(figsize=(2, 6))  
+norm = plt.Normalize(vmin=0, vmax=10000)
+fig.colorbar(plt.cm.ScalarMappable(norm=norm, cmap=cmap), cax=ax, orientation='vertical')
+
+
+output_path = 'colorbar_purple_yellow.png'
+plt.savefig(output_path, bbox_inches='tight', dpi=300)
+plt.close()
+
+output_path

best_model.pth

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

hyperparameters.py

@@ -0,0 +1,169 @@
+import optuna
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+import matplotlib.pyplot as plt
+import os
+
+
+script_path = os.path.abspath(__file__)
+script_dir = os.path.dirname(script_path)
+os.chdir(script_dir)
+
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+print(f"Using device: {device}")
+
+
+data = pd.read_csv('data.csv')
+
+
+X = data.drop(columns=['OS.time']).values
+y = data['OS.time'].values
+
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+
+X_train_tensor = torch.tensor(X_train, dtype=torch.float32).to(device)
+y_train_tensor = torch.tensor(y_train, dtype=torch.float32).view(-1, 1).to(device)
+X_test_tensor = torch.tensor(X_test, dtype=torch.float32).to(device)
+y_test_tensor = torch.tensor(y_test, dtype=torch.float32).view(-1, 1).to(device)
+
+train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
+
+train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
+
+
+class SimpleNN(nn.Module):
+    def __init__(self, input_dim, hidden_dim, num_layers, dropout_rate):
+        super(SimpleNN, self).__init__()
+        self.layers = nn.ModuleList()
+        last_dim = input_dim
+        for _ in range(num_layers):
+            self.layers.append(nn.Linear(last_dim, hidden_dim))
+            self.layers.append(nn.ReLU())
+            self.layers.append(nn.Dropout(dropout_rate))
+            last_dim = hidden_dim
+        self.layers.append(nn.Linear(last_dim, 1))
+
+    def forward(self, x):
+        for layer in self.layers:
+            x = layer(x)
+        return x
+
+
+def weights_init(m):
+    if isinstance(m, nn.Linear):
+        nn.init.kaiming_uniform_(m.weight)
+        nn.init.zeros_(m.bias)
+
+
+def objective(trial):
+    
+    num_layers = trial.suggest_int('num_layers', 2, 5)
+    hidden_dim = trial.suggest_int('hidden_dim', 50, 200)
+    dropout_rate = trial.suggest_float('dropout_rate', 0.2, 0.5)
+    momentum = trial.suggest_float('momentum', 0.5, 0.9)
+    num_epochs = trial.suggest_int('num_epochs', 6000, 10000)
+
+    
+    model = SimpleNN(X_train.shape[1], hidden_dim, num_layers, dropout_rate).to(device)
+    model.apply(weights_init)
+
+    criterion = nn.MSELoss()
+    optimizer = optim.SGD(model.parameters(), lr=0.0001, momentum=momentum)
+
+    
+    for epoch in range(num_epochs):
+        model.train()
+        for inputs, targets in train_loader:
+            optimizer.zero_grad()
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            loss.backward()
+            torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+            optimizer.step()
+        
+        
+        model.eval()
+        test_loss = 0
+        with torch.no_grad():
+            for inputs, targets in test_loader:
+                outputs = model(inputs)
+                test_loss += criterion(outputs, targets).item() * inputs.size(0)
+        
+        test_loss /= len(test_loader.dataset)
+
+        trial.report(test_loss, epoch)
+        
+        if trial.should_prune():
+            raise optuna.exceptions.TrialPruned()
+    
+    return test_loss
+
+
+study = optuna.create_study(direction='minimize')
+study.optimize(objective, n_trials=200)
+
+
+print(f"Best trial parameters: {study.best_trial.params}")
+print(f"Best trial test loss: {study.best_trial.value}")
+
+
+import optuna.visualization as vis
+
+vis.plot_param_importances(study).show()
+
+vis.plot_parallel_coordinate(study).show()
+
+best_params = study.best_trial.params
+
+model = SimpleNN(X_train.shape[1], best_params['hidden_dim'], best_params['num_layers'], best_params['dropout_rate']).to(device)
+model.apply(weights_init)
+
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=0.0001, momentum=best_params['momentum'])
+
+test_losses = []
+for epoch in range(best_params['num_epochs']):
+    model.train()
+    for inputs, targets in train_loader:
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs, targets)
+        loss.backward()
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+    
+    model.eval()
+    test_loss = 0
+    with torch.no_grad():
+        for inputs, targets in test_loader:
+            outputs = model(inputs)
+            test_loss += criterion(outputs, targets).item() * inputs.size(0)
+    
+    test_loss /= len(test_loader.dataset)
+
+    if epoch % 100 == 0:
+        test_losses.append(test_loss)
+        print(f'Epoch {epoch+1}, Test Loss: {test_loss}')
+
+print("Training completed with best hyperparameters.")
+
+
+plt.figure(figsize=(10, 5))
+plt.plot(range(1, len(test_losses) * 100, 100), test_losses, label='Test Loss')
+plt.xlabel('Epoch')
+plt.ylabel('Test Loss')
+plt.title('Test Loss over Epochs')
+plt.legend()
+plt.show()

methane.py

@@ -0,0 +1,257 @@
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import matplotlib.cm as cm
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+from sklearn.metrics import r2_score
+from scipy.stats import pearsonr
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, TensorDataset
+import os
+
+
+script_path = os.path.abspath(__file__)
+script_dir = os.path.dirname(script_path)
+os.chdir(script_dir)
+
+
+data = pd.read_csv('data.csv')
+
+
+X = data.drop(columns=['OS.time']).values
+y = data['OS.time'].values
+
+
+print(np.isnan(X).sum(), np.isnan(y).sum())
+print(np.isinf(X).sum(), np.isinf(y).sum())
+
+scaler = StandardScaler()
+X_scaled = scaler.fit_transform(X)
+
+X_train, X_test, y_train, y_test = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+
+X_train_tensor = torch.tensor(X_train, dtype=torch.float32)
+y_train_tensor = torch.tensor(y_train, dtype=torch.float32).view(-1, 1)
+X_test_tensor = torch.tensor(X_test, dtype=torch.float32)
+y_test_tensor = torch.tensor(y_test, dtype=torch.float32).view(-1, 1)
+
+train_dataset = TensorDataset(X_train_tensor, y_train_tensor)
+test_dataset = TensorDataset(X_test_tensor, y_test_tensor)
+
+train_loader = DataLoader(train_dataset, batch_size=32, shuffle=True)
+test_loader = DataLoader(test_dataset, batch_size=32, shuffle=False)
+
+
+class SimpleNN(nn.Module):
+    def __init__(self, input_dim):
+        super(SimpleNN, self).__init__()
+        self.fc1 = nn.Linear(input_dim, 100)
+        self.dropout1 = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(100, 100)
+        self.dropout2 = nn.Dropout(0.5)
+        self.fc3 = nn.Linear(100, 1)
+    
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = self.dropout1(x)
+        x = torch.relu(self.fc2(x))
+        x = self.dropout2(x)
+        x = self.fc3(x)
+        return x
+
+
+def weights_init(m):
+    if isinstance(m, nn.Linear):
+        nn.init.kaiming_uniform_(m.weight)
+        nn.init.zeros_(m.bias)
+
+model = SimpleNN(X_train.shape[1])
+model.apply(weights_init)
+
+criterion = nn.MSELoss()
+optimizer = optim.SGD(model.parameters(), lr=0.0001, momentum=0.9)
+
+
+best_test_loss = float('inf')
+best_model_state = None
+
+
+num_epochs = 10000
+train_losses = []
+test_losses = []
+all_predictions = []
+gradients = []
+r2_scores = []
+
+for epoch in range(num_epochs):
+    model.train()
+    train_loss = 0.0
+    epoch_gradients = []
+    for inputs, targets in train_loader:
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs, targets)
+        loss.backward()
+        
+        for param in model.parameters():
+            epoch_gradients.append(param.grad.abs().mean().item())
+        
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        optimizer.step()
+        train_loss += loss.item()
+    
+    train_loss /= len(train_loader)
+    train_losses.append(train_loss)
+    gradients.append(epoch_gradients)
+    print(f'Epoch {epoch+1}, Train Loss: {train_loss}')
+    
+    model.eval()
+    test_loss = 0.0
+    predictions = []
+    with torch.no_grad():
+        for inputs, targets in test_loader:
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            test_loss += loss.item()
+            predictions.append(outputs.numpy())
+    
+    test_loss /= len(test_loader)
+    test_losses.append(test_loss)
+    all_predictions.append(predictions)
+    
+    
+    predictions_flat = np.concatenate(predictions).flatten()
+    r2 = r2_score(y_test, predictions_flat)
+    r2_scores.append(r2)
+    print(f'Epoch {epoch+1}, R^2: {r2}')
+    
+    
+    if test_loss < best_test_loss:
+        best_test_loss = test_loss
+        best_model_state = model.state_dict()
+        torch.save(best_model_state, 'best_model.pth')
+        print(f'Saved new best model at epoch {epoch+1} with test loss {test_loss}')
+
+
+
+
+
+plt.figure(figsize=(10, 5))
+plt.plot(range(1, num_epochs + 1), train_losses, label='Train Loss')
+plt.plot(range(1, num_epochs + 1), test_losses, label='Test Loss')
+
+
+window_size = 50
+train_losses_ma = pd.Series(train_losses).rolling(window=window_size).mean()
+test_losses_ma = pd.Series(test_losses).rolling(window=window_size).mean()
+
+plt.plot(range(1, num_epochs + 1), train_losses_ma, label='Train Loss (MA)', linestyle='--')
+plt.plot(range(1, num_epochs + 1), test_losses_ma, label='Test Loss (MA)', linestyle='--')
+
+plt.xlabel('Epoch')
+plt.ylabel('Loss')
+plt.title('Train and Test Loss with Moving Average')
+plt.legend()
+plt.savefig('train_test_loss.png')
+plt.close()
+
+
+final_predictions = np.array(all_predictions[-1]).flatten()
+actuals = y_test_tensor.numpy().flatten()
+
+
+correlation, p_value = pearsonr(actuals, final_predictions)
+print(f'Pearson Correlation: {correlation}')
+print(f'P-value: {p_value}')
+
+
+plt.figure(figsize=(10, 5))
+plt.scatter(actuals, final_predictions, color='blue', label=f'Predictions vs Actuals (r={correlation:.2f}, p={p_value:.2g})')
+plt.plot([min(actuals), max(actuals)], [min(actuals), max(actuals)], color='red', linestyle='--', label='Ideal Fit')
+plt.xlabel('Actual OS.time')
+plt.ylabel('Predicted OS.time')
+plt.title('Predictions vs Actuals')
+plt.legend()
+plt.savefig('predictions_vs_actuals.png')
+plt.close()
+
+
+errors = final_predictions - actuals
+plt.figure(figsize=(10, 5))
+plt.hist(errors, bins=30, color='purple', alpha=0.7)
+plt.xlabel('Prediction Error')
+plt.ylabel('Frequency')
+plt.title('Error Distribution')
+plt.savefig('error_distribution.png')
+plt.close()
+
+
+actuals = y_test_tensor.numpy()
+colors = cm.viridis(np.linspace(0, 1, num_epochs))
+
+plt.figure(figsize=(10, 5))
+plt.plot(actuals, label='Actual Values', color='b', marker='o', linestyle='-')
+
+for i in range(0, num_epochs, max(1, num_epochs // 100)):
+    predictions = np.array(all_predictions[i]).flatten()
+    plt.plot(predictions, label=f'Epoch {i+1}', color=colors[i], linestyle='--')
+
+plt.xlabel('Sample Index')
+plt.ylabel('OS.time')
+plt.title('Actual vs Predicted Values Over Time')
+plt.legend(bbox_to_anchor=(1.05, 1), loc='upper left')
+plt.savefig('actual_vs_predicted_over_time.png')
+plt.close()
+
+
+for i, layer in enumerate(model.children()):
+    if isinstance(layer, nn.Linear):
+        plt.figure(figsize=(10, 5))
+        plt.hist(layer.weight.detach().numpy().flatten(), bins=30, alpha=0.6, color='blue')
+        plt.xlabel(f'Layer {i+1} Weights')
+        plt.ylabel('Frequency')
+        plt.title(f'Weight Distribution of Layer {i+1}')
+        plt.savefig(f'layer_{i+1}_weight_distribution.png')
+        plt.close()
+
+
+importances = np.abs(model.fc1.weight.detach().numpy()).sum(axis=0)
+indices = np.argsort(importances)
+
+plt.figure(figsize=(10, 5))
+plt.barh(range(X_train.shape[1]), importances[indices], align='center')
+plt.xlabel('Importance')
+plt.ylabel('Feature Index')
+plt.title('Feature Importances in the First Layer')
+plt.savefig('feature_importances.png')
+plt.close()
+
+
+for i, layer in enumerate(model.children()):
+    if isinstance(layer, nn.Linear):
+        plt.figure(figsize=(10, 5))
+        plt.imshow(layer.weight.detach().numpy(), aspect='auto', cmap='viridis')
+        plt.colorbar()
+        plt.title(f'Weight Heatmap of Layer {i+1}')
+        plt.xlabel('Input Features')
+        plt.ylabel('Neurons')
+        plt.savefig(f'layer_{i+1}_weight_heatmap.png')
+        plt.close()
+
+
+plt.figure(figsize=(10, 5))
+plt.plot(range(1, num_epochs + 1), r2_scores, label='R^2 Score')
+
+
+r2_scores_ma = pd.Series(r2_scores).rolling(window=window_size).mean()
+plt.plot(range(1, num_epochs + 1), r2_scores_ma, label='R^2 Score (MA)', linestyle='--')
+
+plt.xlabel('Epoch')
+plt.ylabel('R^2 Score')
+plt.title('R^2 Score over Epochs')
+plt.legend()
+plt.savefig('r2_over_epochs.png')
+plt.close()

use_pre_pca.py

@@ -0,0 +1,36 @@
+import pandas as pd
+from sklearn.preprocessing import StandardScaler
+import joblib
+import os
+script_path=os.path.abspath(__file__)
+script_dir=os.path.dirname(script_path)
+os.chdir(script_dir)
+
+pca_model_path = 'pca_model.pkl'
+loaded_pca = joblib.load(pca_model_path)
+
+
+
+file_path = 'TCGA-LGG.methylation450.tsv'  
+new_data = pd.read_csv(file_path, sep='\t', index_col=0)
+
+
+
+new_data.dropna(inplace=True)
+
+
+scaler = StandardScaler()
+scaled_new_data = scaler.fit_transform(new_data.T)  
+
+
+new_principal_components = loaded_pca.transform(scaled_new_data)
+
+
+sample_ids = new_data.columns
+new_principal_df = pd.DataFrame(data=new_principal_components, columns=[f'Principal Component {i+1}' for i in range(loaded_pca.n_components_)], index=sample_ids)
+
+
+print(new_principal_df)
+
+output_file_path = 'pca_principal_components.csv'
+new_principal_df.to_csv(output_file_path)

webplot.py

@@ -0,0 +1,81 @@
+import torch
+import torch.nn as nn
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+import os
+script_path=os.path.abspath(__file__)
+script_dir=os.path.dirname(script_path)
+os.chdir(script_dir)
+class SimpleNN(nn.Module):
+    def __init__(self, input_dim):
+        super(SimpleNN, self).__init__()
+        self.fc1 = nn.Linear(input_dim, 100)
+        self.dropout1 = nn.Dropout(0.5)
+        self.fc2 = nn.Linear(100, 100)
+        self.dropout2 = nn.Dropout(0.5)
+        self.fc3 = nn.Linear(100, 1)
+    
+    def forward(self, x):
+        x = torch.relu(self.fc1(x))
+        x = self.dropout1(x)
+        x = torch.relu(self.fc2(x))
+        x = self.dropout2(x)
+        x = self.fc3(x)
+        return x
+
+
+input_dim = 51  
+model = SimpleNN(input_dim)
+model.load_state_dict(torch.load('best_model.pth'))
+model.eval()
+
+
+weights = []
+weights.append(model.fc1.weight.detach().numpy())
+weights.append(model.fc2.weight.detach().numpy())
+weights.append(model.fc3.weight.detach().numpy())
+
+
+layers = [input_dim, 100, 100, 1]
+
+
+def draw_neural_network(layers, weights):
+    G = nx.Graph()
+
+    
+    pos = {}
+    layer_nodes = []
+    for i, num_nodes in enumerate(layers):
+        layer_nodes.append([])
+        for j in range(num_nodes):
+            node_name = f'L{i}_N{j}'
+            layer_nodes[-1].append(node_name)
+            pos[node_name] = (i, -j + num_nodes // 2)  
+
+    
+    edges = []
+    edge_colors = []
+    for i in range(len(layers) - 1):
+        for j, node in enumerate(layer_nodes[i]):
+            for k, next_node in enumerate(layer_nodes[i+1]):
+                weight = weights[i][k, j]
+                edges.append((node, next_node))
+                edge_colors.append(weight)
+
+    G.add_edges_from(edges)
+
+    
+    plt.figure(figsize=(10, 10))
+    nx.draw(G, pos, with_labels=False, node_size=700, node_color='lightblue', 
+            edge_color=edge_colors, edge_cmap=plt.cm.viridis, 
+            width=2, edge_vmin=min(edge_colors), edge_vmax=max(edge_colors))
+
+    
+    for key, value in pos.items():
+        plt.text(value[0], value[1] + 0.1, key, ha='center', va='center')
+
+    plt.title("Neural Network Visualization")
+    plt.show()
+
+draw_neural_network(layers, weights)