spacr 0.0.18__py3-none-any.whl → 0.0.21__py3-none-any.whl

spacr/get_alfafold_structures.py

@@ -0,0 +1,72 @@
+import csv
+import os
+import requests
+
+def download_alphafold_structures(tsv_location, dst, version="4"):
+    # Create the destination directory if it does not exist
+    dst_pdb = os.path.join(dst,'pdb')
+    dst_cif = os.path.join(dst,'cif')
+    dst_pae = os.path.join(dst,'pae')
+    
+    if not os.path.exists(dst):
+        os.makedirs(dst)
+    if not os.path.exists(dst_pdb):
+        os.makedirs(dst_pdb)
+    if not os.path.exists(dst_cif):
+        os.makedirs(dst_cif)
+    if not os.path.exists(dst_pae):
+        os.makedirs(dst_pae)
+
+    failed_downloads = []  # List to keep track of failed downloads
+
+    # Open the TSV file and read entries
+    with open(tsv_location, 'r') as tsv_file:
+        reader = csv.DictReader(tsv_file, delimiter='\t')
+        for row in reader:
+            entry = row['Entry']
+            af_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.pdb"
+            cif_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-model_v{version}.cif"
+            pae_link = f"https://alphafold.ebi.ac.uk/files/AF-{entry}-F1-predicted_aligned_error_v{version}.json"
+
+            try:
+                response_pdb = requests.get(af_link, stream=True)
+                response_cif = requests.get(cif_link, stream=True)
+                response_pae = requests.get(pae_link, stream=True)
+                if response_pdb.status_code == 200:
+                    
+                    # Save the PDB file
+                    with open(os.path.join(dst_pdb, f"AF-{entry}-F1-model_v{version}.pdb"), 'wb') as pdb_file:
+                        pdb_file.write(response_pdb.content)
+                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.pdb")
+                    
+                    # Save the CIF file
+                    with open(os.path.join(dst_cif, f"AF-{entry}-F1-model_v{version}.cif"), 'wb') as cif_file:
+                        cif_file.write(response_cif.content)
+                    print(f"Downloaded: AF-{entry}-F1-model_v{version}.cif")
+                    
+                    # Save the PAE file
+                    with open(os.path.join(dst_pae, f"AF-{entry}-F1-predicted_aligned_error_v{version}.json"), 'wb') as pdb_file:
+                        pdb_file.write(response_pae.content)
+                    print(f"Downloaded: AF-{entry}-F1-predicted_aligned_error_v{version}.json")
+                    
+                else:
+                    # If the file could not be downloaded, record the entry
+                    failed_downloads.append(entry)
+                    print(f"Failed to download structure for: {entry}")
+            except Exception as e:
+                print(f"Error downloading structure for {entry}: {e}")
+                failed_downloads.append(entry)
+
+    # Save the list of failed downloads to a CSV file in the destination folder
+    if failed_downloads:
+        with open(os.path.join(dst, 'failed_downloads.csv'), 'w', newline='') as failed_file:
+            writer = csv.writer(failed_file)
+            writer.writerow(['Entry'])
+            for entry in failed_downloads:
+                writer.writerow([entry])
+        print(f"Failed download entries saved to: {os.path.join(dst, 'failed_downloads.csv')}")
+
+# Example usage:
+tsv_location = '/home/carruthers/Downloads/GT1_proteome/GT1_proteins_uniprot.tsv'  # Replace with the path to your TSV file containing a list of UniProt entries
+dst_folder = '/home/carruthers/Downloads/GT1_proteome'  # Replace with your destination folder
+download_alphafold_structures(tsv_location, dst_folder)

spacr/graph_learning.py

@@ -1,82 +1,276 @@
+import os
 import torch
-from torch_geometric.data import Data
-from torch_geometric.nn import GCNConv, global_mean_pool
+import torch.nn as nn
 import torch.nn.functional as F
-from torch.nn import Linear
+from collections import defaultdict
+from torch.utils.data import Dataset, DataLoader
 import pandas as pd
-from sklearn.preprocessing import LabelEncoder
+import numpy as np
+import torch.optim as optim
 
-#1. Cell Nodes: Represent individual cells. Each cell node could have attributes like cell area, nuclear area, and a CNN-based phenotype score. These nodes could be visualized as circles labeled with "C".
-#2. Well Nodes: Represent wells in the 384-well plates. Wells are intermediary nodes that link cells to genes based on the experimental setup. Each well could contain multiple cells and be associated with certain gene knockouts. These nodes might not have direct attributes in the schematic but serve to connect cell nodes to gene nodes. These can be visualized as squares labeled with "W".
-#3. Gene Nodes: Represent genes that have been knocked out. Gene nodes are connected to well nodes, indicating which genes are knocked out in each well. Attributes might include the fraction of sequencing reads for that gene, indicating its relative abundance or importance in the well. These nodes can be visualized as diamonds labeled with "G".
-    
-# Define a simple GNN model
-class GNN(torch.nn.Module):
-    def __init__(self):
-        super(GNN, self).__init__()
-        self.conv1 = GCNConv(1, 16)  # Assume node features are 1-dimensional for simplicity
-        self.conv2 = GCNConv(16, 32)
-        self.out = Linear(32, 1)  # Predicting a single score for each cell/well
-
-    def forward(self, data):
-        x, edge_index = data.x, data.edge_index
+def generate_graphs(sequencing, scores, cell_min, gene_min_read):
+    # Load and preprocess sequencing (gene) data
+    gene_df = pd.read_csv(sequencing)
+    gene_df = gene_df.rename(columns={'prc': 'well_id', 'grna': 'gene_id', 'count': 'read_count'})
+    # Filter out genes with read counts less than gene_min_read
+    gene_df = gene_df[gene_df['read_count'] >= gene_min_read]
+    total_reads_per_well = gene_df.groupby('well_id')['read_count'].sum().reset_index(name='total_reads')
+    gene_df = gene_df.merge(total_reads_per_well, on='well_id')
+    gene_df['well_read_fraction'] = gene_df['read_count'] / gene_df['total_reads']
+
+    # Load and preprocess cell score data
+    cell_df = pd.read_csv(scores)
+    cell_df = cell_df[['prcfo', 'prc', 'pred']].rename(columns={'prcfo': 'cell_id', 'prc': 'well_id', 'pred': 'score'})
+
+    # Create a global mapping of gene IDs to indices
+    unique_genes = gene_df['gene_id'].unique()
+    gene_id_to_index = {gene_id: index for index, gene_id in enumerate(unique_genes)}
+
+    graphs = []
+    for well_id in pd.unique(gene_df['well_id']):
+        well_genes = gene_df[gene_df['well_id'] == well_id]
+        well_cells = cell_df[cell_df['well_id'] == well_id]
+
+        # Skip wells with no cells or genes or with fewer cells than threshold
+        if well_cells.empty or well_genes.empty or len(well_cells) < cell_min:
+            continue
+
+        # Initialize gene features tensor with zeros for all unique genes
+        gene_features = torch.zeros((len(gene_id_to_index), 1), dtype=torch.float)
+
+        # Update gene features tensor with well_read_fraction for genes present in this well
+        for _, row in well_genes.iterrows():
+            gene_index = gene_id_to_index[row['gene_id']]
+            gene_features[gene_index] = torch.tensor([[row['well_read_fraction']]])
+
+        # Prepare cell features (scores)
+        cell_features = torch.tensor(well_cells['score'].values, dtype=torch.float).view(-1, 1)
+
+        num_genes = len(gene_id_to_index)
+        num_cells = cell_features.size(0)
+        num_nodes = num_genes + num_cells
+
+        # Create adjacency matrix connecting each cell to all genes in the well
+        adj = torch.zeros((num_nodes, num_nodes), dtype=torch.float)
+        for _, row in well_genes.iterrows():
+            gene_index = gene_id_to_index[row['gene_id']]
+            adj[num_genes:, gene_index] = 1
+
+        graph = {
+            'adjacency_matrix': adj,
+            'gene_features': gene_features,
+            'cell_features': cell_features,
+            'num_cells': num_cells,
+            'num_genes': num_genes
+        }
+        graphs.append(graph)
+
+    print(f'Generated dataset with {len(graphs)} graphs')
+    return graphs, gene_id_to_index
+
+def print_graphs_info(graphs, gene_id_to_index):
+    # Invert the gene_id_to_index mapping for easy lookup
+    index_to_gene_id = {v: k for k, v in gene_id_to_index.items()}
+
+    for i, graph in enumerate(graphs, start=1):
+        print(f"Graph {i}:")
+        num_genes = graph['num_genes']
+        num_cells = graph['num_cells']
+        gene_features = graph['gene_features']
+        cell_features = graph['cell_features']
+
+        print(f"  Number of Genes: {num_genes}")
+        print(f"  Number of Cells: {num_cells}")
+
+        # Identify genes present in the graph based on non-zero feature values
+        present_genes = [index_to_gene_id[idx] for idx, feature in enumerate(gene_features) if feature.item() > 0]
+        print("  Genes present in this Graph:", present_genes)
+
+        # Display gene features for genes present in the graph
+        print("  Gene Features:")
+        for gene_id in present_genes:
+            idx = gene_id_to_index[gene_id]
+            print(f"    {gene_id}: {gene_features[idx].item()}")
+
+        # Display a sample of cell features, for brevity
+        print("  Cell Features (sample):")
+        for idx, feature in enumerate(cell_features[:min(5, len(cell_features))]):
+            print(f"    Cell {idx+1}: {feature.item()}")
+
+        print("-" * 40)
+
+class Attention(nn.Module):
+    def __init__(self, feature_dim, attn_dim, dropout_rate=0.1):
+        super(Attention, self).__init__()
+        self.query = nn.Linear(feature_dim, attn_dim)
+        self.key = nn.Linear(feature_dim, attn_dim)
+        self.value = nn.Linear(feature_dim, feature_dim)
+        self.scale = 1.0 / (attn_dim ** 0.5)
+        self.dropout = nn.Dropout(dropout_rate)
+
+    def forward(self, gene_features, cell_features):
+        # Queries come from the cell features
+        q = self.query(cell_features)
+        # Keys and values come from the gene features
+        k = self.key(gene_features)
+        v = self.value(gene_features)
         
-        # Two layers of GCN convolution
-        x = F.relu(self.conv1(x, edge_index))
-        x = F.dropout(x, training=self.training)
-        x = self.conv2(x, edge_index)
+        # Compute attention weights
+        attn_weights = torch.matmul(q, k.transpose(-2, -1)) * self.scale
+        attn_weights = F.softmax(attn_weights, dim=-1)
+        # Apply dropout to attention weights
+        attn_weights = self.dropout(attn_weights)  
+
+        # Apply attention weights to the values
+        attn_output = torch.matmul(attn_weights, v)
         
-        # Global mean pooling
-        x = global_mean_pool(x, batch=torch.tensor([0, 0, 0]))  # Assume all nodes belong to the same graph
-        x = self.out(x)
-        return x
+        return attn_output, attn_weights
 
-def construct_graph(cell_data_loc, well_data_loc, well_id='prc', infer_id='gene', features=[]):
-    
-    # Example loading step
-    cells_df = pd.read_csv(cell_data_loc)
-    wells_df = pd.read_csv(well_data_loc)
-    
-    # Encode categorical data
-    well_encoder = LabelEncoder()
-    gene_encoder = LabelEncoder()
-    
-    cells_df['well_id'] = well_encoder.fit_transform(cells_df[well_id])
-    wells_df['gene_id'] = gene_encoder.fit_transform(wells_df[infer_id])
-    
-    # Assume cell features are in columns ['feature1', 'feature2', ...]
-    cell_features = torch.tensor(cells_df[[features]].values, dtype=torch.float)
-    
-    # Creating nodes for cells and assigning phenotype scores as labels
-    y = torch.tensor(cells_df['phenotype_score'].values, dtype=torch.float).unsqueeze(1)
-    
-    # Constructing edges (this is simplified; you should define edges based on your data structure)
-    edge_index = torch.tensor([[0, 1], [1, 2], [2, 0]], dtype=torch.long).t().contiguous()
-    
-    graphdata = Data(x=cell_features, edge_index=torch.tensor(edge_index, dtype=torch.long), y=y)
-    return graphdata, len(features)
+class GraphTransformer(nn.Module):
+    def __init__(self, gene_feature_size, cell_feature_size, hidden_dim, output_dim, attn_dim, dropout_rate=0.1):
+        super(GraphTransformer, self).__init__()
+        self.gene_transform = nn.Linear(gene_feature_size, hidden_dim)
+        self.cell_transform = nn.Linear(cell_feature_size, hidden_dim)
+        self.dropout = nn.Dropout(dropout_rate)
 
+        # Attention layer to let each cell attend to all genes
+        self.attention = Attention(hidden_dim, attn_dim)
 
-def train_gnn(cell_data_loc, well_data_loc, well_id='prc', infer_id='gene', lr=0.01, epochs=100):
+        # This layer is used to transform the combined features after attention
+        self.combine_transform = nn.Linear(2 * hidden_dim, hidden_dim)
+
+        # Output layer for predicting cell scores, ensuring it matches the number of cells
+        self.cell_output = nn.Linear(hidden_dim, output_dim)
+
+    def forward(self, adjacency_matrix, gene_features, cell_features):
+        # Apply initial transformation to gene and cell features
+        transformed_gene_features = F.relu(self.gene_transform(gene_features))
+        transformed_cell_features = F.relu(self.cell_transform(cell_features))
+
+        # Incorporate attention mechanism
+        attn_output, attn_weights = self.attention(transformed_gene_features, transformed_cell_features)
+
+        # Combine the transformed cell features with the attention output features
+        combined_cell_features = torch.cat((transformed_cell_features, attn_output), dim=1)
+        
+        # Apply dropout here as well
+        combined_cell_features = self.dropout(combined_cell_features)  
+
+        combined_cell_features = F.relu(self.combine_transform(combined_cell_features))
+
+        # Combine gene and cell features for message passing
+        combined_features = torch.cat((transformed_gene_features, combined_cell_features), dim=0)
+
+        # Apply message passing via adjacency matrix multiplication
+        message_passed_features = torch.matmul(adjacency_matrix, combined_features)
+
+        # Predict cell scores from the post-message passed cell features
+        cell_scores = self.cell_output(message_passed_features[-cell_features.size(0):])
+
+        return cell_scores, attn_weights
     
+def train_graph_transformer(graphs, lr=0.01, dropout_rate=0.1, weight_decay=0.00001, epochs=100, save_fldr='', acc_threshold = 0.1):
     device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    data, nr_of_features = construct_graph(cell_data_loc, well_data_loc).to(device)
-    
-    model = GNN(feature_size=nr_of_features).to(device)
+    model = GraphTransformer(gene_feature_size=1, cell_feature_size=1, hidden_dim=256, output_dim=1, attn_dim=128, dropout_rate=dropout_rate).to(device)
 
-    # Assuming binary classification for simplicity
-    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
-    criterion = torch.nn.BCELoss()
+    criterion = nn.MSELoss()
+    #optimizer = torch.optim.Adam(model.parameters(), lr=lr)
+    optimizer = optim.AdamW(model.parameters(), lr=lr, weight_decay=weight_decay)
 
+    training_log = []
+    
+    accumulate_grad_batches=1
+    threshold=acc_threshold
+    
     for epoch in range(epochs):
         model.train()
+        total_loss = 0
+        total_correct = 0
+        total_samples = 0
         optimizer.zero_grad()
-        out = model(data)
-        loss = criterion(out[data.train_mask], data.y[data.train_mask])
-        loss.backward()
-        optimizer.step()
+        batch_count = 0  # Initialize batch_count
         
-        if epoch % 10 == 0:
-            print(f'Epoch {epoch}, Loss: {loss.item()}')
-            
-    return model
+        for graph in graphs:
+            adjacency_matrix = graph['adjacency_matrix'].to(device)
+            gene_features = graph['gene_features'].to(device)
+            cell_features = graph['cell_features'].to(device)
+            num_cells = graph['num_cells']
+            predictions, attn_weights = model(adjacency_matrix, gene_features, cell_features)
+            predictions = predictions.squeeze()
+            true_scores = cell_features[:num_cells, 0]
+            loss = criterion(predictions, true_scores) / accumulate_grad_batches
+            loss.backward()
+
+            # Calculate "accuracy"
+            with torch.no_grad():
+                correct_predictions = (torch.abs(predictions - true_scores) / true_scores <= threshold).sum().item()
+                total_correct += correct_predictions
+                total_samples += num_cells
+
+            batch_count += 1  # Increment batch_count
+            if batch_count % accumulate_grad_batches == 0 or batch_count == len(graphs):
+                optimizer.step()
+                optimizer.zero_grad()
+
+            total_loss += loss.item() * accumulate_grad_batches
+        
+        accuracy = total_correct / total_samples
+        training_log.append({"Epoch": epoch+1, "Average Loss": total_loss / len(graphs), "Accuracy": accuracy})
+        print(f"Epoch {epoch+1}, Loss: {total_loss / len(graphs)}, Accuracy: {accuracy}", end="\r", flush=True)
+    
+    # Save the training log and model as before
+    os.makedirs(save_fldr, exist_ok=True)
+    log_path = os.path.join(save_fldr, 'training_log.csv')
+    training_log_df = pd.DataFrame(training_log)
+    training_log_df.to_csv(log_path, index=False)
+    print(f"Training log saved to {log_path}")
+    
+    model_path = os.path.join(save_fldr, 'model.pth')
+    torch.save(model.state_dict(), model_path)
+    print(f"Model saved to {model_path}")
+
+    return model
+        
+def annotate_cells_with_genes(graphs, model, gene_id_to_index):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    model.to(device)
+    model.eval()
+    annotated_data = []
+
+    with torch.no_grad():
+        for graph in graphs:
+            adjacency_matrix = graph['adjacency_matrix'].to(device)
+            gene_features = graph['gene_features'].to(device)
+            cell_features = graph['cell_features'].to(device)
+
+            predictions, attn_weights = model(adjacency_matrix, gene_features, cell_features)
+            predictions = np.atleast_1d(predictions.squeeze().cpu().numpy())
+            attn_weights = np.atleast_2d(attn_weights.squeeze().cpu().numpy())
+
+            # This approach assumes all genes in gene_id_to_index are used in the model.
+            # Create a list of gene IDs present in this specific graph.
+            present_gene_ids = [key for key, value in gene_id_to_index.items() if value < gene_features.size(0)]
+
+            for cell_idx in range(cell_features.size(0)):
+                true_score = cell_features[cell_idx, 0].item()
+                predicted_score = predictions[cell_idx]
+                
+                # Find the index of the most probable gene. 
+                most_probable_gene_idx = attn_weights[cell_idx].argmax()
+
+                if len(present_gene_ids) > most_probable_gene_idx:  # Ensure index is within the range
+                    most_probable_gene_id = present_gene_ids[most_probable_gene_idx]
+                    most_probable_gene_score = attn_weights[cell_idx, most_probable_gene_idx] if attn_weights.ndim > 1 else attn_weights[most_probable_gene_idx]
+
+                    annotated_data.append({
+                        "Cell ID": cell_idx,
+                        "Most Probable Gene": most_probable_gene_id,
+                        "Cell Score": true_score,
+                        "Predicted Cell Score": predicted_score,
+                        "Probability Score for Highest Gene": most_probable_gene_score
+                    })
+                else:
+                    # Handle the case where the index is out of bounds - this should not happen but is here for robustness
+                    print("Error: Gene index out of bounds. This might indicate a mismatch in the model's output.")
+
+    return pd.DataFrame(annotated_data)

spacr/graph_learning_lap.py

@@ -1,82 +1,84 @@
 import torch
-from torch_geometric.data import Data
-from torch_geometric.nn import GCNConv, global_mean_pool
+import torch.nn as nn
 import torch.nn.functional as F
-from torch.nn import Linear
-import pandas as pd
-from sklearn.preprocessing import LabelEncoder
+from torch.utils.data import Dataset, DataLoader, TensorDataset
 
-#1. Cell Nodes: Represent individual cells. Each cell node could have attributes like cell area, nuclear area, and a CNN-based phenotype score. These nodes could be visualized as circles labeled with "C".
-#2. Well Nodes: Represent wells in the 384-well plates. Wells are intermediary nodes that link cells to genes based on the experimental setup. Each well could contain multiple cells and be associated with certain gene knockouts. These nodes might not have direct attributes in the schematic but serve to connect cell nodes to gene nodes. These can be visualized as squares labeled with "W".
-#3. Gene Nodes: Represent genes that have been knocked out. Gene nodes are connected to well nodes, indicating which genes are knocked out in each well. Attributes might include the fraction of sequencing reads for that gene, indicating its relative abundance or importance in the well. These nodes can be visualized as diamonds labeled with "G".
-    
-# Define a simple GNN model
-class GNN(torch.nn.Module):
-    def __init__(self):
-        super(GNN, self).__init__()
-        self.conv1 = GCNConv(1, 16)  # Assume node features are 1-dimensional for simplicity
-        self.conv2 = GCNConv(16, 32)
-        self.out = Linear(32, 1)  # Predicting a single score for each cell/well
+# Let's assume that the feature embedding part and the dataset loading part
+# has already been taken care of, and your data is already in the format
+# suitable for PyTorch (i.e., Tensors).
 
-    def forward(self, data):
-        x, edge_index = data.x, data.edge_index
+class FeatureEmbedder(nn.Module):
+    def __init__(self, vocab_sizes, embedding_size):
+        super(FeatureEmbedder, self).__init__()
+        self.embeddings = nn.ModuleDict({
+            key: nn.Embedding(num_embeddings=vocab_size+1, 
+                              embedding_dim=embedding_size, 
+                              padding_idx=vocab_size)
+            for key, vocab_size in vocab_sizes.items()
+        })
+        # Adding the 'visit' embedding
+        self.embeddings['visit'] = nn.Parameter(torch.zeros(1, embedding_size))
+
+    def forward(self, feature_map, max_num_codes):
+        # Implementation will depend on how you want to handle sparse data
+        # This is just a placeholder
+        embeddings = {}
+        masks = {}
+        for key, tensor in feature_map.items():
+            embeddings[key] = self.embeddings[key](tensor.long())
+            mask = torch.ones_like(tensor, dtype=torch.float32)
+            masks[key] = mask.unsqueeze(-1)
         
-        # Two layers of GCN convolution
-        x = F.relu(self.conv1(x, edge_index))
-        x = F.dropout(x, training=self.training)
-        x = self.conv2(x, edge_index)
+        # Batch size hardcoded for simplicity in example
+        batch_size = 1  # Replace with actual batch size
+        embeddings['visit'] = self.embeddings['visit'].expand(batch_size, -1, -1)
+        masks['visit'] = torch.ones(batch_size, 1)
         
-        # Global mean pooling
-        x = global_mean_pool(x, batch=torch.tensor([0, 0, 0]))  # Assume all nodes belong to the same graph
-        x = self.out(x)
-        return x
-
-def construct_graph(cell_data_loc, well_data_loc, well_id='prc', infer_id='gene', features=[]):
-    
-    # Example loading step
-    cells_df = pd.read_csv(cell_data_loc)
-    wells_df = pd.read_csv(well_data_loc)
-    
-    # Encode categorical data
-    well_encoder = LabelEncoder()
-    gene_encoder = LabelEncoder()
-    
-    cells_df['well_id'] = well_encoder.fit_transform(cells_df[well_id])
-    wells_df['gene_id'] = gene_encoder.fit_transform(wells_df[infer_id])
-    
-    # Assume cell features are in columns ['feature1', 'feature2', ...]
-    cell_features = torch.tensor(cells_df[[features]].values, dtype=torch.float)
-    
-    # Creating nodes for cells and assigning phenotype scores as labels
-    y = torch.tensor(cells_df['phenotype_score'].values, dtype=torch.float).unsqueeze(1)
-    
-    # Constructing edges (this is simplified; you should define edges based on your data structure)
-    edge_index = torch.tensor([[0, 1], [1, 2], [2, 0]], dtype=torch.long).t().contiguous()
-    
-    graphdata = Data(x=cell_features, edge_index=torch.tensor(edge_index, dtype=torch.long), y=y)
-    return graphdata, len(features)
-
+        return embeddings, masks
 
-def train_gnn(cell_data_loc, well_data_loc, well_id='prc', infer_id='gene', lr=0.01, epochs=100):
-    
-    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
-    data, nr_of_features = construct_graph(cell_data_loc, well_data_loc).to(device)
-    
-    model = GNN(feature_size=nr_of_features).to(device)
+class GraphConvolutionalTransformer(nn.Module):
+    def __init__(self, embedding_size=128, num_attention_heads=1, **kwargs):
+        super(GraphConvolutionalTransformer, self).__init__()
+        # Transformer Blocks
+        self.layers = nn.ModuleList([
+            nn.TransformerEncoderLayer(
+                d_model=embedding_size,
+                nhead=num_attention_heads,
+                batch_first=True) 
+            for _ in range(kwargs.get('num_transformer_stack', 3))
+        ])
+        # Output Layer for Classification
+        self.output_layer = nn.Linear(embedding_size, 1)
 
-    # Assuming binary classification for simplicity
-    optimizer = torch.optim.Adam(model.parameters(), lr=lr)
-    criterion = torch.nn.BCELoss()
+    def feedforward(self, features, mask=None, training=None):
+        # Implement feedforward logic (placeholder)
+        pass
 
-    for epoch in range(epochs):
-        model.train()
-        optimizer.zero_grad()
-        out = model(data)
-        loss = criterion(out[data.train_mask], data.y[data.train_mask])
-        loss.backward()
-        optimizer.step()
+    def forward(self, embeddings, masks, mask=None, training=False):
+        features = embeddings
+        attentions = []  # Storing attentions if needed
         
-        if epoch % 10 == 0:
-            print(f'Epoch {epoch}, Loss: {loss.item()}')
+        # Pass through each Transformer block
+        for layer in self.layers:
+            features = layer(features)  # Apply transformer encoding here
             
-    return model
+            if mask is not None:
+                features = features * mask
+            
+        logits = self.output_layer(features[:, 0, :])  # Using the 'visit' embedding for classification
+        return logits, attentions
+
+# Usage Example
+vocab_sizes = {'dx_ints':3249, 'proc_ints':2210}
+embedding_size = 128
+gct_params = {
+    'embedding_size': embedding_size,
+    'num_transformer_stack': 3,
+    'num_attention_heads': 1
+}
+feature_embedder = FeatureEmbedder(vocab_sizes, embedding_size)
+gct_model = GraphConvolutionalTransformer(**gct_params)
+
+# Assume `feature_map` is a dictionary of tensors, and `max_num_codes` is provided
+embeddings, masks = feature_embedder(feature_map, max_num_codes)
+logits, attentions = gct_model(embeddings, masks)

spacr/gui_classify_app.py

@@ -17,7 +17,7 @@ except AttributeError:
 
 from .logger import log_function_call
 from .gui_utils import ScrollableFrame, StdoutRedirector, create_dark_mode, set_dark_style, set_default_font, generate_fields, process_stdout_stderr, safe_literal_eval, clear_canvas, main_thread_update_function
-from .gui_utils import classify_variables, check_classify_gui_settings, train_test_model_wrapper
+from .gui_utils import classify_variables, check_classify_gui_settings, train_test_model_wrapper, read_settings_from_csv, update_settings_from_csv  
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -39,7 +39,6 @@ def run_classify_gui(q, fig_queue, stop_requested):
     process_stdout_stderr(q)
     try:
         settings = check_classify_gui_settings(vars_dict)
-        #settings = add_mask_gui_defaults(settings)
         for key in settings:
             value = settings[key]
             print(key, value, type(value))
@@ -65,25 +64,10 @@ def import_settings(scrollable_frame):
     global vars_dict
 
     csv_file_path = filedialog.askopenfilename(filetypes=[("CSV files", "*.csv")])
-    
-    if not csv_file_path:
-        return
-    
-    imported_variables = {}
-
-    with open(csv_file_path, newline='') as csvfile:
-        reader = csv.DictReader(csvfile)
-        for row in reader:
-            key = row['Key']
-            value = row['Value']
-            # Evaluate the value safely using safe_literal_eval
-            imported_variables[key] = safe_literal_eval(value)
-
-    # Track changed variables and apply the imported ones, printing changes as we go
-    for key, var in vars_dict.items():
-        if key in imported_variables and var.get() != imported_variables[key]:
-            print(f"Updating '{key}' from '{var.get()}' to '{imported_variables[key]}'")
-            var.set(imported_variables[key])
+    csv_settings = read_settings_from_csv(csv_file_path)
+    variables = classify_variables()
+    new_settings = update_settings_from_csv(variables, csv_settings)
+    vars_dict = generate_fields(new_settings, scrollable_frame)
 
 @log_function_call
 def initiate_classify_root(width, height):