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.
- GNODEVAE/CLEAR.py +172 -0
- GNODEVAE/GODEVAE.py +413 -0
- GNODEVAE/GODEVAE_agent.py +385 -0
- GNODEVAE/GODEVAE_env.py +758 -0
- GNODEVAE/GODEVAE_trainer.py +309 -0
- GNODEVAE/SC3.py +198 -0
- GNODEVAE/__init__.py +6 -0
- GNODEVAE/agent.py +472 -0
- GNODEVAE/env.py +474 -0
- GNODEVAE/mixin.py +418 -0
- GNODEVAE/module.py +939 -0
- GNODEVAE/module_refined.py +561 -0
- GNODEVAE/partition_time.py +185 -0
- GNODEVAE/scGCC.py +184 -0
- GNODEVAE/scGNN.py +146 -0
- GNODEVAE/trainer.py +397 -0
- GNODEVAE/utils.py +460 -0
- GNODEVAE/utils_ODE.py +140 -0
- gnodevae-0.0.3.dist-info/METADATA +330 -0
- gnodevae-0.0.3.dist-info/RECORD +23 -0
- gnodevae-0.0.3.dist-info/WHEEL +5 -0
- gnodevae-0.0.3.dist-info/licenses/LICENSE +21 -0
- gnodevae-0.0.3.dist-info/top_level.txt +1 -0
|
@@ -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
|