gnodevae 0.0.3__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,185 @@
1
+ import numpy as np
2
+ import pandas as pd
3
+ import torch
4
+ import torch.nn as nn
5
+ import torch.nn.functional as F
6
+ from torchdiffeq import odeint
7
+ from .mixin import scviMixin
8
+
9
+ device = torch.device('cuda') if torch.cuda.is_available() else 'cpu'
10
+
11
+ class VAE(nn.Module, scviMixin):
12
+ def __init__(self, input_dim, hidden_dim, latent_dim):
13
+ super(VAE, self).__init__()
14
+ # Encoder
15
+ self.fc1 = nn.Linear(input_dim, hidden_dim)
16
+ self.fc_mu = nn.Linear(hidden_dim, latent_dim) # Mean of latent space
17
+ self.fc_logvar = nn.Linear(hidden_dim, latent_dim) # Log variance of latent space
18
+
19
+ # Decoder
20
+ self.fc2 = nn.Linear(latent_dim, hidden_dim)
21
+ self.fc3 = nn.Linear(hidden_dim, input_dim)
22
+
23
+ self.time_predictor = TimePredictor(latent_dim)
24
+
25
+ self.disp = nn.Parameter(torch.randn(input_dim))
26
+
27
+ def encode(self, x):
28
+ h = F.relu(self.fc1(x))
29
+ mu = self.fc_mu(h)
30
+ logvar = self.fc_logvar(h)
31
+ z = self.reparameterize(mu, logvar)
32
+ return z, mu, logvar
33
+
34
+ def reparameterize(self, mu, logvar):
35
+ std = torch.exp(0.5 * logvar) # Standard deviation
36
+ eps = torch.randn_like(std) # Random noise
37
+ return mu + eps * std # Reparameterization trick
38
+
39
+ def decode(self, z):
40
+ h = F.relu(self.fc2(z))
41
+ return torch.softmax(self.fc3(h), dim=-1) # Output is in [0, 1]
42
+
43
+ def forward(self, x):
44
+ z, mu, logvar = self.encode(x)
45
+ t = self.time_predictor(z)
46
+ recon_x = self.decode(z)
47
+ return recon_x, z , mu, logvar, t
48
+
49
+ def vae_loss(self, q_m, q_s, x, pred_x):
50
+ p_m = torch.zeros_like(q_m)
51
+ p_s = torch.zeros_like(q_s)
52
+ kl_loss = self._normal_kl(q_m, q_s, p_m, p_s).sum(-1).mean()
53
+ # Compute losses
54
+ l = x.sum(-1).view(-1, 1)
55
+ pred_x = pred_x * l
56
+ disp = torch.exp(self.disp)
57
+ recon_loss = -self._log_nb(x, pred_x, disp).sum(-1).mean()
58
+ return kl_loss, recon_loss
59
+
60
+ # Define the Time Predictor model
61
+ class TimePredictor(nn.Module):
62
+ def __init__(self, latent_dim):
63
+ super(TimePredictor, self).__init__()
64
+ self.net = nn.Sequential(
65
+ nn.Linear(latent_dim, 128),
66
+ nn.ReLU(),
67
+ nn.Linear(128, 1),
68
+ nn.Sigmoid() # Ensures time values are between 0 and 1
69
+ )
70
+
71
+ def forward(self, z):
72
+ return self.net(z)
73
+
74
+ # Define the ODE function (dynamics model)
75
+ class LatentDynamics(nn.Module):
76
+ def __init__(self, latent_dim):
77
+ super(LatentDynamics, self).__init__()
78
+ self.net = nn.Sequential(
79
+ nn.Linear(latent_dim, 128),
80
+ nn.ELU(),
81
+ nn.Linear(128, latent_dim)
82
+ )
83
+
84
+ def forward(self, t, z):
85
+ # Note: torchdiffeq expects the function signature to be (t, z)
86
+ return self.net(z)
87
+
88
+
89
+ class PartitionHandler:
90
+ def __init__(self, agent, batch, device):
91
+ self.fetch_data(agent, batch)
92
+
93
+ # Initialize models
94
+ self.dynamics_model = LatentDynamics(10).to(device)
95
+
96
+ self.vae = VAE(self.df.shape[1]-2, 128, 10).to(device)
97
+
98
+ # Initialize optimizer
99
+ self.optimizer = torch.optim.Adam(
100
+ self.vae.parameters(),
101
+ lr=1e-3
102
+ )
103
+
104
+ self.device = device
105
+
106
+ def fit(self, num_epochs):
107
+
108
+ x = torch.tensor(self.df.iloc[:,:-2].values, device=self.device)
109
+
110
+ for epoch in range(num_epochs):
111
+
112
+ recon_x, z, q_m, q_s, t = self.vae(x)
113
+ kl_loss, recon_loss = self.vae.vae_loss(q_m, q_s, x, recon_x)
114
+
115
+ t = t.ravel()
116
+ idx = torch.argsort(t)
117
+ t_sort, z_sort = t[idx], z[idx]
118
+
119
+ # Keep only unique times (remove duplicates)
120
+ mask = torch.cat([
121
+ (t_sort[:-1] != t_sort[1:]), # Find where adjacent times differ
122
+ torch.tensor([True], device=t.device) # Always keep last point
123
+ ])
124
+ t_uniq, z_uniq = t_sort[mask], z_sort[mask]
125
+
126
+ try:
127
+ pred_z = odeint(
128
+ self.dynamics_model,
129
+ z_uniq[0],
130
+ t_uniq,
131
+ method='dopri5',
132
+ options={'atol': 1e-7, 'rtol': 1e-5}
133
+ )
134
+ except:
135
+ # If adaptive solver fails, try with a simpler fixed-step method
136
+ pred_z = odeint(
137
+ self.dynamics_model,
138
+ z_uniq[0],
139
+ t_uniq,
140
+ method='rk4'
141
+ )
142
+ pred_x_ode = self.vae.decode(pred_z)
143
+
144
+ l = x.sum(-1).view(-1, 1)[idx][mask]
145
+ pred_x_ode = pred_x_ode * l
146
+ disp = torch.exp(self.vae.disp)
147
+
148
+ recon_loss_ode = -self.vae._log_nb(x[idx][mask], pred_x_ode, disp).sum(-1).mean()
149
+ z_div = F.mse_loss(z_uniq, pred_z, reduction="none").sum(-1).mean()
150
+
151
+ loss = recon_loss + recon_loss_ode + kl_loss + z_div
152
+
153
+ self.optimizer.zero_grad()
154
+ loss.backward()
155
+ self.optimizer.step()
156
+ if (epoch+1) % 100 == 0:
157
+ print(f"Epoch {epoch + 1}/{num_epochs}, Loss: {loss.item():.6f}")
158
+ return self
159
+
160
+ def predict(self, ):
161
+ with torch.no_grad():
162
+ res = self.vae(torch.tensor(self.df.iloc[:,:-2].values, device=self.device))
163
+ self.df['time'] = res[-1].cpu().numpy()
164
+
165
+ def fetch_data(self, agent, batch=256):
166
+ size = int(batch / len(agent.cdata))
167
+ df_ls = []
168
+ idx_dict = dict()
169
+ for i, cd in enumerate(agent.cdata):
170
+ idx_dict.update(dict(zip(cd.y.cpu().numpy(), np.repeat(i, len(cd.y)))))
171
+ idx = np.random.choice(len(cd.y), size=size, replace=False)
172
+ df = pd.DataFrame(cd.x.cpu().numpy()[idx])
173
+ df['idx'] = cd.y.cpu().numpy()[idx]
174
+ df['cat'] = i
175
+ df_ls.append(df)
176
+ self.idx_dict = idx_dict
177
+ self.df = pd.concat(df_ls)
178
+
179
+
180
+
181
+
182
+
183
+
184
+
185
+
GNODEVAE/scGCC.py ADDED
@@ -0,0 +1,184 @@
1
+ import torch
2
+ import torch.nn as nn
3
+ import torch.nn.functional as F
4
+ from torch.utils.data import Dataset, DataLoader
5
+ from torch_geometric.data import Data
6
+ from torch_geometric.nn import GATConv
7
+ from torch_geometric.utils import to_undirected
8
+ from torch_geometric.loader import NeighborLoader # Added import
9
+ from anndata import AnnData
10
+ import scanpy as sc
11
+ import numpy as np
12
+ import warnings
13
+ from tqdm import tqdm
14
+
15
+ # --- Helper Functions and Classes ---
16
+
17
+ def _full_block(in_features, out_features, p_drop=0.0):
18
+ return nn.Sequential(
19
+ nn.Linear(in_features, out_features, bias=True),
20
+ nn.ReLU(),
21
+ nn.Dropout(p=p_drop),
22
+ )
23
+
24
+ # --- Core Model Components ---
25
+
26
+ class GATEncoder(nn.Module):
27
+ def __init__(self, in_channels, latent_dim, num_heads=4, dropout=0.4, use_mlp=False):
28
+ super().__init__()
29
+ self.gat_layer_1 = GATConv(in_channels, 128, heads=num_heads, dropout=dropout, concat=True)
30
+ self.gat_layer_2 = GATConv(128 * num_heads, latent_dim, heads=num_heads, dropout=dropout, concat=False)
31
+ self.fc = nn.Sequential(_full_block(latent_dim, 512, 0.4), _full_block(512, latent_dim)) if use_mlp else None
32
+
33
+ def forward(self, x, edge_index):
34
+ x = F.relu(self.gat_layer_1(x, edge_index))
35
+ x = F.dropout(x, p=0.4, training=self.training)
36
+ x = self.gat_layer_2(x, edge_index)
37
+ return self.fc(x) if self.fc else x
38
+
39
+ class MoCo(nn.Module):
40
+ def __init__(self, base_encoder, num_genes, latent_dim, r=1024, m=0.99, T=0.2, heads=4, mlp=False):
41
+ super().__init__()
42
+ self.r = r
43
+ self.m = m
44
+ self.T = T
45
+ self.encoder_q = base_encoder(num_genes, latent_dim, num_heads=heads, use_mlp=mlp)
46
+ self.encoder_k = base_encoder(num_genes, latent_dim, num_heads=heads, use_mlp=mlp)
47
+
48
+ for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
49
+ param_k.data.copy_(param_q.data)
50
+ param_k.requires_grad = False
51
+
52
+ self.register_buffer("queue", F.normalize(torch.randn(latent_dim, r), dim=0))
53
+ self.register_buffer("queue_ptr", torch.zeros(1, dtype=torch.long))
54
+
55
+ @torch.no_grad()
56
+ def _momentum_update_key_encoder(self):
57
+ for param_q, param_k in zip(self.encoder_q.parameters(), self.encoder_k.parameters()):
58
+ param_k.data = param_k.data * self.m + param_q.data * (1. - self.m)
59
+
60
+ @torch.no_grad()
61
+ def _dequeue_and_enqueue(self, keys):
62
+ batch_size = keys.shape[0]
63
+ ptr = int(self.queue_ptr)
64
+ if self.r % batch_size == 0:
65
+ self.queue[:, ptr:ptr + batch_size] = keys.T
66
+ self.queue_ptr[0] = (ptr + batch_size) % self.r
67
+
68
+ def forward(self, im_q, im_k, edge_index, num_seed_nodes):
69
+ # Encode the full subgraph features
70
+ q_all = self.encoder_q(im_q, edge_index)
71
+ q_seed = F.normalize(q_all[:num_seed_nodes], dim=1) # Extract and normalize seed node features
72
+
73
+ with torch.no_grad():
74
+ self._momentum_update_key_encoder()
75
+ k_all = self.encoder_k(im_k, edge_index)
76
+ k_seed = F.normalize(k_all[:num_seed_nodes], dim=1) # Extract and normalize seed node features
77
+
78
+ l_pos = torch.einsum('nc,nc->n', [q_seed, k_seed]).unsqueeze(-1)
79
+ l_neg = torch.einsum('nc,ck->nk', [q_seed, self.queue.clone().detach()])
80
+ logits = torch.cat([l_pos, l_neg], dim=1) / self.T
81
+ labels = torch.zeros(logits.shape[0], dtype=torch.long, device=q_seed.device)
82
+ self._dequeue_and_enqueue(k_seed)
83
+ return logits, labels
84
+
85
+ @torch.no_grad()
86
+ def inference(self, x, edge_index):
87
+ self.encoder_k.eval()
88
+ return self.encoder_k(x, edge_index)
89
+
90
+ # --- Main scGCC Class ---
91
+
92
+ class scGCC:
93
+ def __init__(self, adata: AnnData, use_highly_variable: bool = True, layer: str = None, latent_dim: int = 256):
94
+ self.adata = adata.copy()
95
+ self.use_highly_variable = use_highly_variable
96
+ self.layer = layer
97
+ self.latent_dim = latent_dim
98
+ self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
99
+ self.model = None
100
+
101
+ self._prepare_data()
102
+
103
+ def _prepare_data(self):
104
+ if self.layer and self.layer in self.adata.layers:
105
+ self.adata.X = self.adata.layers[self.layer]
106
+
107
+ if self.use_highly_variable:
108
+ if 'highly_variable' not in self.adata.var.keys():
109
+ sc.pp.highly_variable_genes(self.adata)
110
+ self.adata = self.adata[:, self.adata.var['highly_variable']].copy()
111
+
112
+ def _build_graph(self, k=10):
113
+ sc.pp.neighbors(self.adata, n_neighbors=k, use_rep='X')
114
+ edge_index = torch.from_numpy(np.vstack(self.adata.obsp['connectivities'].nonzero())).to(torch.long)
115
+ return Data(x=torch.from_numpy(self.adata.X.toarray()).float(), edge_index=to_undirected(edge_index))
116
+
117
+ def _augment_batch(self, x_batch, aug_prob=0.5):
118
+ # Apply masking
119
+ if np.random.rand() < aug_prob:
120
+ mask = torch.rand(x_batch.shape, device=x_batch.device) < 0.2 # 20% masking
121
+ x_batch[mask] = 0
122
+
123
+ # Apply Gaussian Noise
124
+ if np.random.rand() < aug_prob:
125
+ mask = torch.rand(x_batch.shape, device=x_batch.device) < 0.3 # 30% noise
126
+ noise = torch.randn_like(x_batch) * 0.2 # Gaussian noise with std 0.2
127
+ x_batch[mask] += noise[mask]
128
+ return x_batch
129
+
130
+ def fit(self, epochs=20, lr=0.1, batch_size=512, verbose=True):
131
+ global_graph = self._build_graph().to(self.device)
132
+
133
+ # Use NeighborLoader to create batches of subgraphs
134
+ train_loader = NeighborLoader(
135
+ global_graph,
136
+ num_neighbors=[-1], # Sample all neighbors for full graph, or specify for subgraphs
137
+ batch_size=batch_size,
138
+ shuffle=True,
139
+ num_workers=0, # For simplicity, no multiprocessing for now
140
+ )
141
+
142
+ self.model = MoCo(GATEncoder, self.adata.n_vars, self.latent_dim, r=batch_size).to(self.device)
143
+ optimizer = torch.optim.SGD(self.model.parameters(), lr, momentum=0.9, weight_decay=1e-4)
144
+ criterion = nn.CrossEntropyLoss()
145
+
146
+ for epoch in range(epochs):
147
+ self.model.train()
148
+ total_loss = 0
149
+
150
+ progress_bar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}", disable=not verbose, miniters=10)
151
+ for data in progress_bar: # data is now a Data object from NeighborLoader
152
+ data = data.to(self.device)
153
+
154
+ im_q = data.x # Original features for the batch
155
+ im_k = self._augment_batch(data.x.clone().detach()) # Augmented features for the batch
156
+
157
+ logits, labels = self.model(im_q, im_k, data.edge_index, data.batch_size)
158
+ loss = criterion(logits, labels)
159
+
160
+ optimizer.zero_grad()
161
+ loss.backward()
162
+ optimizer.step()
163
+ total_loss += loss.item()
164
+
165
+ if verbose:
166
+ progress_bar.set_postfix(loss=loss.item())
167
+
168
+ if verbose:
169
+ print(f"Epoch {epoch+1}/{epochs}, Average Loss: {total_loss / len(train_loader):.4f}")
170
+ return self
171
+
172
+ def get_embedding(self):
173
+ if not self.model:
174
+ raise RuntimeError("Model has not been trained. Please call .fit() first.")
175
+
176
+ self.model.eval()
177
+ global_graph = self._build_graph().to(self.device)
178
+
179
+ with torch.no_grad():
180
+ full_data = torch.from_numpy(self.adata.X.toarray() if hasattr(self.adata.X, 'toarray') else self.adata.X).float().to(self.device)
181
+ embedding = self.model.inference(full_data, global_graph.edge_index).cpu().numpy()
182
+
183
+ self.adata.obsm['X_scgcc'] = embedding
184
+ return embedding
GNODEVAE/scGNN.py ADDED
@@ -0,0 +1,146 @@
1
+ import torch
2
+ import torch.nn as nn
3
+ import torch.nn.functional as F
4
+ from torch.utils.data import Dataset, DataLoader
5
+ import numpy as np
6
+ import scanpy as sc
7
+ from anndata import AnnData
8
+ from sklearn.neighbors import NearestNeighbors
9
+ from sklearn.cluster import KMeans
10
+ from tqdm import tqdm
11
+
12
+ # --- Core Model Components ---
13
+
14
+ class _VAE(nn.Module):
15
+ """Internal Variational Autoencoder."""
16
+ def __init__(self, dim):
17
+ super().__init__()
18
+ self.encoder = nn.Sequential(nn.Linear(dim, 400), nn.ReLU())
19
+ self.mu = nn.Linear(400, 20)
20
+ self.logvar = nn.Linear(400, 20)
21
+ self.decoder = nn.Sequential(nn.Linear(20, 400), nn.ReLU(), nn.Linear(400, dim), nn.Sigmoid())
22
+
23
+ def encode(self, x):
24
+ h = self.encoder(x)
25
+ return self.mu(h), self.logvar(h)
26
+
27
+ def reparameterize(self, mu, logvar):
28
+ std = torch.exp(0.5 * logvar)
29
+ return mu + torch.randn_like(std) * std
30
+
31
+ def forward(self, x):
32
+ mu, logvar = self.encode(x)
33
+ z = self.reparameterize(mu, logvar)
34
+ return self.decoder(z), mu, logvar, z
35
+
36
+ # --- Dataset Class ---
37
+
38
+ class _scGNNDataset(Dataset):
39
+ """Internal Dataset for scGNN."""
40
+ def __init__(self, adata):
41
+ self.features = adata.X.toarray() if hasattr(adata.X, 'toarray') else adata.X
42
+
43
+ def __len__(self):
44
+ return self.features.shape[0]
45
+
46
+ def __getitem__(self, idx):
47
+ return torch.from_numpy(self.features[idx].flatten()).float(), idx
48
+
49
+ # --- Main scGNN Class ---
50
+
51
+ class scGNN:
52
+ def __init__(self, adata: AnnData, use_highly_variable: bool = True, layer: str = None, latent_dim: int = 20):
53
+ self.adata = adata.copy()
54
+ self.use_highly_variable = use_highly_variable
55
+ self.layer = layer
56
+ self.latent_dim = latent_dim
57
+ self.device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
58
+ self.model = None
59
+ self._prepare_data()
60
+
61
+ def _prepare_data(self):
62
+ if self.layer and self.layer in self.adata.layers:
63
+ self.adata.X = self.adata.layers[self.layer]
64
+
65
+ # Preprocessing: normalize and log-transform
66
+ sc.pp.normalize_total(self.adata, target_sum=1e4)
67
+ sc.pp.log1p(self.adata)
68
+
69
+ if self.use_highly_variable:
70
+ if 'highly_variable' not in self.adata.var.keys():
71
+ sc.pp.highly_variable_genes(self.adata)
72
+ self.adata = self.adata[:, self.adata.var['highly_variable']].copy()
73
+
74
+ # Check for NaN values in the input data after preprocessing
75
+ if np.isnan(self.adata.X.toarray()).any():
76
+ raise ValueError("Input AnnData.X contains NaN values after preprocessing. Please handle missing data.")
77
+
78
+ def _build_graph_regu(self, features, k=10):
79
+ nbrs = NearestNeighbors(n_neighbors=k + 1, metric='euclidean').fit(features)
80
+ distances, indices = nbrs.kneighbors(features)
81
+ adj = np.zeros((features.shape[0], features.shape[0]))
82
+ for i in range(len(features)):
83
+ for j_idx, j in enumerate(indices[i]):
84
+ if i != j:
85
+ adj[i, j] = 1.0 / (1.0 + distances[i, j_idx])
86
+ return torch.from_numpy(adj).float().to(self.device)
87
+
88
+ def _loss_function(self, recon_x, x, mu, logvar, graph_regu, gamma, regu_para):
89
+ recon_loss = F.mse_loss(recon_x, x, reduction='sum')
90
+ graph_loss = torch.mean(torch.matmul(graph_regu, (recon_x - x)**2))
91
+ kld_loss = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())
92
+ return gamma * recon_loss + regu_para * graph_loss + kld_loss
93
+
94
+ def fit(self, regu_epochs=200, em_epochs=100, em_iterations=5, lr=1e-3, k=10, gamma=0.1, regu_para=0.001, verbose=True):
95
+ dataset = _scGNNDataset(self.adata)
96
+ train_loader = DataLoader(dataset, batch_size=128, shuffle=False)
97
+
98
+ self.model = _VAE(self.adata.n_vars).to(self.device)
99
+ optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)
100
+
101
+ # Initial training with graph regularization
102
+ initial_graph_regu = self._build_graph_regu(dataset.features, k=k)
103
+ for epoch in tqdm(range(regu_epochs), desc="Initial Graph-VAE Training", disable=not verbose, miniters=10):
104
+ self._train_epoch(train_loader, optimizer, initial_graph_regu, gamma, regu_para)
105
+
106
+ # EM-like iterations
107
+ for i in range(em_iterations):
108
+ embeddings = self.get_embedding(internal_call=True)
109
+ graph_regu = self._build_graph_regu(embeddings, k=k)
110
+ for epoch in tqdm(range(em_epochs), desc=f"EM Iteration {i+1}/{em_iterations}", disable=not verbose, miniters=10):
111
+ self._train_epoch(train_loader, optimizer, graph_regu, gamma, regu_para)
112
+
113
+ return self
114
+
115
+ def _train_epoch(self, loader, optimizer, graph_regu, gamma, regu_para):
116
+ self.model.train()
117
+ for data, idx in loader:
118
+ data = data.to(self.device)
119
+ optimizer.zero_grad()
120
+ recon, mu, logvar, _ = self.model(data)
121
+ loss = self._loss_function(recon, data, mu, logvar, graph_regu[idx, :][:, idx], gamma, regu_para)
122
+ loss.backward()
123
+ optimizer.step()
124
+
125
+ def get_embedding(self, internal_call=False) -> np.ndarray:
126
+ if not self.model:
127
+ raise RuntimeError("Model has not been trained. Please call .fit() first.")
128
+
129
+ self.model.eval()
130
+ embeddings = []
131
+ full_data = self.adata.X.toarray() if hasattr(self.adata.X, 'toarray') else self.adata.X
132
+ data_loader = DataLoader(_scGNNDataset(self.adata), batch_size=128)
133
+
134
+ with torch.no_grad():
135
+ for data, _ in data_loader:
136
+ data = data.to(self.device)
137
+ _, mu, _, _ = self.model(data)
138
+ embeddings.append(mu.cpu().numpy())
139
+
140
+ embedding_matrix = np.vstack(embeddings)
141
+ # Check for NaN values in the generated embeddings
142
+ if np.isnan(embedding_matrix).any():
143
+ raise ValueError("Generated embeddings contain NaN values. This indicates a potential issue with the model training or architecture.")
144
+ if not internal_call:
145
+ self.adata.obsm['X_scgnn'] = embedding_matrix
146
+ return embedding_matrix