Divergent Mechanisms of Antidepressant Efficacy: A Unified Computational Comparison of Synaptogenesis, Stabilization, and Tonic Inhibition in a Model of Depression.

1. # %% [markdown]
2. # # Modes of Antidepressants
4. # %%
5. """
6. ================================================================================
7. MULTI-MECHANISM ANTIDEPRESSANT COMPARISON EXPERIMENT
8. WITH ISO-DOSE FAIR COMPARISON PIPELINE
9. ================================================================================
11. This script runs only Experiment 4: comparing three antidepressant mechanisms:
12. 1. KETAMINE-LIKE: Gradient-guided synaptogenesis
13. 2. SSRI-LIKE: Gradual stabilization without structural changes
14. 3. NEUROSTEROID-LIKE: Tonic inhibition enhancement
16. All treatments start from identical pruned (depressed) network states.
18. VERSION 2.0 ADDITIONS:
19. - Iso-dose comparison pipeline for fair cross-mechanism comparison
20. - L1/L2 weight change norms as mechanism-agnostic "dose" proxy
21. - Synaptic turnover measurement
22. - Parameter sweeps to match dose across treatments
23. - Efficiency analysis: outcome per unit dose
24. ================================================================================
25. """
27. import torch
28. import torch.nn as nn
29. import torch.optim as optim
30. import numpy as np
31. from torch.utils.data import DataLoader, TensorDataset
32. from typing import Dict, Tuple, List, Optional, Any
33. from dataclasses import dataclass
34. import copy
35. import warnings
37. warnings.filterwarnings('ignore', category=UserWarning)
39. # ============================================================================
40. # REPRODUCIBILITY
41. # ============================================================================
42. SEED = 42
43. torch.manual_seed(SEED)
44. np.random.seed(SEED)
45. DEVICE = torch.device('cpu')
47. # ============================================================================
48. # CONFIGURATION - Fixed version with proper syntax
49. # ============================================================================
50. CONFIG = {
51. # Data generation
52. 'n_train': 12000,
53. 'n_test': 4000,
54. 'n_clean_test': 2000,
55. 'data_noise': 0.8,
56. 'batch_size': 128,
58. # Network architecture
59. 'hidden_dims': [512, 512, 256],
60. 'input_dim': 2,
61. 'output_dim': 4,
63. # Training hyperparameters
64. 'baseline_epochs': 20,
65. 'baseline_lr': 0.001,
66. 'finetune_epochs': 15,
67. 'finetune_lr': 0.0005,
69. # Pruning parameters
70. 'prune_sparsity': 0.95,
72. # Regrowth parameters
73. 'regrow_fraction': 0.5,
74. 'regrow_init_scale': 0.03,
75. 'gradient_accumulation_batches': 30,
77. # Stress levels for evaluation
78. 'extended_stress_levels': {
79. 'none': 0.0,
80. 'moderate': 0.5,
81. 'high': 1.0,
82. 'severe': 1.5,
83. 'extreme': 2.5
84. },
86. # ========================================================================
87. # MONOAMINERGIC (SSRI-LIKE) TREATMENT PARAMETERS
88. # ========================================================================
89. # Biological rationale: SSRIs increase synaptic serotonin, leading to
90. # gradual receptor adaptations over weeks. No rapid synaptogenesis.
91. # Network analog: Fixed sparsity, very low LR, gradual noise reduction.
92. 'monoaminergic_epochs': 100,
93. 'monoaminergic_lr': 1e-5,
94. 'monoaminergic_initial_stress': 0.5,
96. # ========================================================================
97. # NEUROSTEROID (GABAergic) TREATMENT PARAMETERS
98. # ========================================================================
99. # Biological rationale: Neurosteroids enhance tonic GABA inhibition,
100. # reducing network excitability rapidly (days, not weeks).
101. # Network analog: Global activation damping, bounded activations.
102. 'neurosteroid_inhibition_strength': 0.7,
103. 'neurosteroid_use_tanh': True,
104. 'neurosteroid_consolidation_epochs': 10,
106. # ========================================================================
107. # MULTI-MECHANISM COMPARISON PARAMETERS
108. # ========================================================================
109. 'comparison_ketamine_regrow': 0.5,
110. 'comparison_ketamine_epochs': 15,
111. 'comparison_ssri_epochs': 100,
112. 'comparison_neurosteroid_strength': 0.7,
113. 'comparison_neurosteroid_epochs': 10,
115. # ========================================================================
116. # ISO-DOSE COMPARISON PARAMETERS
117. # ========================================================================
118. 'iso_dose_norm_type': 'l1',
119. 'iso_dose_target_doses': [0.005, 0.010, 0.020, 0.040],
120. 'iso_dose_tolerance': 0.003,
121. 'iso_dose_turnover_threshold': 0.10,
123. # Parameter sweep ranges for iso-dose matching
124. 'ketamine_regrow_sweep': [0.05, 0.10, 0.15, 0.20, 0.25, 0.30, 0.40, 0.50, 0.60, 0.70, 0.80],
125. 'ssri_epochs_sweep': [10, 20, 30, 40, 50, 60, 80, 100, 120, 150, 200],
126. 'ssri_lr_sweep': [1e-6, 5e-6, 1e-5, 2e-5, 5e-5],
127. 'neurosteroid_strength_sweep': [0.50, 0.55, 0.60, 0.65, 0.70, 0.75, 0.80, 0.85, 0.90],
129. # Relapse simulation parameters
130. 'relapse_prune_fraction': 0.40,
131. }
134. # ============================================================================
135. # DATA GENERATION
136. # ============================================================================
137. def generate_blobs(
138. n_samples: int = 10000,
139. noise: float = 0.8,
140. seed: int = None
141. ) -> Tuple[torch.Tensor, torch.Tensor]:
142. """Generate 4-class Gaussian blob classification data."""
143. if seed is not None:
144. rng = np.random.RandomState(seed)
145. else:
146. rng = np.random.RandomState()
148. centers = np.array([[-3, -3], [3, 3], [-3, 3], [3, -3]])
149. labels = rng.randint(0, 4, n_samples)
150. data = centers[labels] + rng.randn(n_samples, 2) * noise
152. return (
153. torch.tensor(data, dtype=torch.float32),
154. torch.tensor(labels, dtype=torch.long)
155. )
158. def create_data_loaders() -> Tuple[DataLoader, DataLoader, DataLoader]:
159. """Create train, test, and clean test data loaders."""
160. train_data, train_labels = generate_blobs(CONFIG['n_train'], noise=CONFIG['data_noise'], seed=100)
161. test_data, test_labels = generate_blobs(CONFIG['n_test'], noise=CONFIG['data_noise'], seed=200)
162. clean_test_data, clean_test_labels = generate_blobs(CONFIG['n_clean_test'], noise=0.0, seed=300)
164. train_loader = DataLoader(TensorDataset(train_data, train_labels), batch_size=CONFIG['batch_size'], shuffle=True)
165. test_loader = DataLoader(TensorDataset(test_data, test_labels), batch_size=1000)
166. clean_test_loader = DataLoader(TensorDataset(clean_test_data, clean_test_labels), batch_size=1000)
168. return train_loader, test_loader, clean_test_loader
171. train_loader, test_loader, clean_test_loader = create_data_loaders()
174. # ============================================================================
175. # NETWORK ARCHITECTURE
176. # ============================================================================
177. class StressAwareNetwork(nn.Module):
178. """
179. Feed-forward network with internal noise injection and GABAergic modulation.
181. Supports three modulation mechanisms:
182. - stress_level: Internal noise (neuromodulatory disruption)
183. - inhibition_strength: Multiplicative damping (tonic GABA inhibition)
184. - use_tanh: Bounded activation (shunting inhibition)
185. """
187. def __init__(self, hidden_dims: List[int] = None):
188. super().__init__()
189. if hidden_dims is None:
190. hidden_dims = CONFIG['hidden_dims']
192. self.fc1 = nn.Linear(CONFIG['input_dim'], hidden_dims[0])
193. self.fc2 = nn.Linear(hidden_dims[0], hidden_dims[1])
194. self.fc3 = nn.Linear(hidden_dims[1], hidden_dims[2])
195. self.fc4 = nn.Linear(hidden_dims[2], CONFIG['output_dim'])
197. self.relu = nn.ReLU()
198. self.tanh = nn.Tanh()
200. # Modulation parameters
201. self.stress_level = 0.0 # Internal noise magnitude
202. self.inhibition_strength = 1.0 # Multiplicative damping (1.0 = none)
203. self.use_tanh = False # Use bounded activation
205. self.weight_layers = ['fc1', 'fc2', 'fc3', 'fc4']
207. def set_stress(self, level: float):
208. """Set internal noise level for stress simulation."""
209. self.stress_level = level
211. def set_inhibition(self, strength: float, use_tanh: bool = False):
212. """Set GABAergic tonic inhibition parameters."""
213. self.inhibition_strength = strength
214. self.use_tanh = use_tanh
216. def reduce_stress_gradually(self, epoch: int, total_epochs: int,
217. initial_stress: float = 0.5, final_stress: float = 0.0):
218. """Linearly reduce internal stress over epochs (SSRI-like)."""
219. progress = epoch / max(total_epochs - 1, 1)
220. self.stress_level = initial_stress + progress * (final_stress - initial_stress)
222. def forward(self, x: torch.Tensor) -> torch.Tensor:
223. """Forward pass with noise injection and inhibitory modulation."""
224. activation = self.tanh if self.use_tanh else self.relu
226. # Layer 1
227. h = activation(self.fc1(x))
228. if self.stress_level > 0:
229. h = h + torch.randn_like(h) * self.stress_level
230. h = h * self.inhibition_strength
232. # Layer 2
233. h = activation(self.fc2(h))
234. if self.stress_level > 0:
235. h = h + torch.randn_like(h) * self.stress_level
236. h = h * self.inhibition_strength
238. # Layer 3
239. h = activation(self.fc3(h))
240. if self.stress_level > 0:
241. h = h + torch.randn_like(h) * self.stress_level
242. h = h * self.inhibition_strength
244. # Output layer (no modulation)
245. return self.fc4(h)
247. def count_parameters(self) -> Tuple[int, int]:
248. """Count total and non-zero parameters."""
249. total = sum(p.numel() for p in self.parameters())
250. nonzero = sum((p != 0).sum().item() for p in self.parameters())
251. return total, nonzero
254. # ============================================================================
255. # PRUNING MANAGER
256. # ============================================================================
257. class PruningManager:
258. """Manages structured pruning and gradient-guided regrowth."""
260. def __init__(self, model: StressAwareNetwork):
261. self.model = model
262. self.masks = {}
263. self.gradient_buffer = {}
265. for name, param in model.named_parameters():
266. if 'weight' in name and param.dim() >= 2:
267. self.masks[name] = torch.ones_like(param, dtype=torch.float32)
268. self.gradient_buffer[name] = torch.zeros_like(param)
270. def prune_by_magnitude(self, sparsity: float, per_layer: bool = True) -> Dict[str, Dict]:
271. """Prune weights by magnitude."""
272. stats = {}
274. for name, param in self.model.named_parameters():
275. if name in self.masks:
276. weights = param.data.abs()
277. threshold = torch.quantile(weights.flatten(), sparsity)
278. self.masks[name] = (weights >= threshold).float()
279. param.data *= self.masks[name]
281. kept = self.masks[name].sum().item()
282. total = self.masks[name].numel()
283. stats[name] = {'kept': int(kept), 'total': total, 'actual_sparsity': 1 - kept/total}
285. return stats
287. def _accumulate_gradients(self, num_batches: int = 30):
288. """Accumulate gradient magnitudes at pruned positions."""
289. model = self.model
290. loss_fn = nn.CrossEntropyLoss()
292. for name in self.gradient_buffer:
293. self.gradient_buffer[name].zero_()
295. model.train()
296. original_stress = model.stress_level
297. model.set_stress(0.0)
299. batch_count = 0
300. for x, y in train_loader:
301. if batch_count >= num_batches:
302. break
303. x, y = x.to(DEVICE), y.to(DEVICE)
304. loss = loss_fn(model(x), y)
305. loss.backward()
307. with torch.no_grad():
308. for name, param in model.named_parameters():
309. if name in self.masks:
310. pruned_mask = (self.masks[name] == 0).float()
311. self.gradient_buffer[name] += param.grad.abs() * pruned_mask
312. model.zero_grad()
313. batch_count += 1
315. model.set_stress(original_stress)
317. def gradient_guided_regrow(self, regrow_fraction: float,
318. init_scale: float = None) -> Dict[str, Dict]:
319. """Regrow pruned connections based on gradient importance."""
320. if init_scale is None:
321. init_scale = CONFIG['regrow_init_scale']
323. self._accumulate_gradients(num_batches=CONFIG['gradient_accumulation_batches'])
325. stats = {}
326. for name, param in self.model.named_parameters():
327. if name not in self.masks:
328. continue
330. mask = self.masks[name]
331. pruned_positions = (mask == 0)
332. num_pruned = pruned_positions.sum().item()
334. if num_pruned == 0:
335. stats[name] = {'regrown': 0, 'still_pruned': 0}
336. continue
338. gradient_scores = self.gradient_buffer[name][pruned_positions]
339. num_regrow = max(1, int(regrow_fraction * num_pruned))
340. num_regrow = min(num_regrow, gradient_scores.numel())
342. _, top_indices = torch.topk(gradient_scores.flatten(), num_regrow)
343. flat_pruned_indices = torch.where(pruned_positions.flatten())[0]
344. regrow_flat_indices = flat_pruned_indices[top_indices]
346. flat_mask = mask.flatten()
347. flat_param = param.data.flatten()
348. flat_mask[regrow_flat_indices] = 1.0
349. flat_param[regrow_flat_indices] = torch.randn(num_regrow) * init_scale
351. self.masks[name] = flat_mask.view_as(mask)
352. param.data = flat_param.view_as(param)
354. stats[name] = {'regrown': num_regrow, 'still_pruned': int(num_pruned - num_regrow)}
356. return stats
358. def apply_masks(self):
359. """Re-apply masks to maintain sparsity."""
360. with torch.no_grad():
361. for name, param in self.model.named_parameters():
362. if name in self.masks:
363. param.data *= self.masks[name]
365. def get_sparsity(self) -> float:
366. """Calculate overall network sparsity."""
367. total = sum(m.numel() for m in self.masks.values())
368. zeros = sum((m == 0).sum().item() for m in self.masks.values())
369. return zeros / total if total > 0 else 0.0
371. def secondary_prune(self, fraction: float) -> Dict[str, Any]:
372. """Simulate relapse by pruning a fraction of surviving weights."""
373. stats = {}
374. total_pruned = 0
376. for name, param in self.model.named_parameters():
377. if name not in self.masks:
378. continue
380. mask = self.masks[name]
381. active_positions = (mask == 1)
382. n_active = active_positions.sum().item()
384. if n_active == 0:
385. continue
387. num_to_prune = int(fraction * n_active)
388. if num_to_prune == 0:
389. continue
391. weights = param.data.abs()
392. weights_active = weights.clone()
393. weights_active[~active_positions] = float('inf')
395. flat_weights = weights_active.flatten()
396. threshold = torch.kthvalue(flat_weights, num_to_prune).values.item()
398. prune_mask = (weights <= threshold) & active_positions
399. mask[prune_mask] = 0
400. param.data[prune_mask] = 0
402. pruned_count = prune_mask.sum().item()
403. total_pruned += pruned_count
405. stats[name] = {
406. 'pruned': pruned_count,
407. 'remaining': n_active - pruned_count
408. }
410. new_sparsity = self.get_sparsity()
412. return {
413. 'total_pruned': total_pruned,
414. 'new_sparsity': new_sparsity,
415. 'layer_stats': stats
416. }
419. # ============================================================================
420. # DOSING METRICS - MECHANISM-AGNOSTIC QUANTIFICATION
421. # ============================================================================
423. @dataclass
424. class DoseMetrics:
425. """Container for all dosing quantification metrics."""
426. l1_norm: float = 0.0
427. l2_norm: float = 0.0
428. synaptic_turnover: float = 0.0
429. sparsity_change: float = 0.0
431. @property
432. def primary_dose(self) -> float:
433. """Primary dose metric (L1 norm by default)."""
434. return self.l1_norm
437. def compute_weight_change_norm(
438. model_pre_state: Dict[str, torch.Tensor],
439. model_post: nn.Module,
440. norm_type: str = 'l1'
441. ) -> float:
442. """
443. Compute total weight change magnitude as mechanism-agnostic dose proxy.
445. Returns normalized dose (total change / total parameters).
446. """
447. delta = 0.0
448. total_params = 0
450. for name, param in model_post.named_parameters():
451. if 'weight' in name and name in model_pre_state:
452. diff = (param.data - model_pre_state[name]).abs()
453. total_params += param.numel()
454. if norm_type == 'l1':
455. delta += diff.sum().item()
456. elif norm_type == 'l2':
457. delta += (diff ** 2).sum().item()
459. if norm_type == 'l2':
460. delta = delta ** 0.5
462. return delta / total_params if total_params > 0 else 0.0
465. def compute_synaptic_turnover(
466. model_pre_state: Dict[str, torch.Tensor],
467. model_post: nn.Module,
468. threshold: float = 0.10
469. ) -> float:
470. """
471. Compute fraction of synapses with significant weight changes.
473. Captures "how many synapses were meaningfully modified" (> threshold relative change).
474. """
475. changed = 0
476. total = 0
478. for name, param in model_post.named_parameters():
479. if 'weight' in name and name in model_pre_state:
480. pre_weights = model_pre_state[name]
481. relative_change = (param.data - pre_weights).abs() / (pre_weights.abs().clamp(min=1e-8))
482. changed += (relative_change > threshold).sum().item()
483. total += param.numel()
485. return changed / total if total > 0 else 0.0
488. def compute_sparsity_change(
489. model_pre_state: Dict[str, torch.Tensor],
490. model_post: nn.Module
491. ) -> float:
492. """Compute absolute change in network sparsity."""
493. def get_sparsity(state_dict):
494. total = 0
495. zeros = 0
496. for name, tensor in state_dict.items():
497. if 'weight' in name:
498. total += tensor.numel()
499. zeros += (tensor.abs() < 1e-8).sum().item()
500. return zeros / total if total > 0 else 0.0
502. pre_sparsity = get_sparsity(model_pre_state)
503. post_sparsity = get_sparsity({n: p.data for n, p in model_post.named_parameters()})
505. return abs(post_sparsity - pre_sparsity)
508. def compute_all_dose_metrics(
509. model_pre_state: Dict[str, torch.Tensor],
510. model_post: nn.Module,
511. turnover_threshold: float = None
512. ) -> DoseMetrics:
513. """Compute all dose quantification metrics."""
514. if turnover_threshold is None:
515. turnover_threshold = CONFIG['iso_dose_turnover_threshold']
517. return DoseMetrics(
518. l1_norm=compute_weight_change_norm(model_pre_state, model_post, 'l1'),
519. l2_norm=compute_weight_change_norm(model_pre_state, model_post, 'l2'),
520. synaptic_turnover=compute_synaptic_turnover(model_pre_state, model_post, turnover_threshold),
521. sparsity_change=compute_sparsity_change(model_pre_state, model_post)
522. )
525. # ============================================================================
526. # TRAINING FUNCTIONS
527. # ============================================================================
528. def train(model: StressAwareNetwork, epochs: int = 15, lr: float = 0.001,
529. pruning_manager: PruningManager = None, verbose: bool = False) -> List[float]:
530. """Standard training loop."""
531. optimizer = optim.Adam(model.parameters(), lr=lr)
532. loss_fn = nn.CrossEntropyLoss()
533. losses = []
535. original_stress = model.stress_level
536. model.set_stress(0.0)
538. for epoch in range(epochs):
539. model.train()
540. epoch_loss = 0.0
541. for x, y in train_loader:
542. x, y = x.to(DEVICE), y.to(DEVICE)
543. optimizer.zero_grad()
544. loss = loss_fn(model(x), y)
545. loss.backward()
546. optimizer.step()
547. if pruning_manager:
548. pruning_manager.apply_masks()
549. epoch_loss += loss.item()
550. losses.append(epoch_loss / len(train_loader))
551. if verbose:
552. print(f" Epoch {epoch+1}/{epochs}, Loss: {losses[-1]:.4f}")
554. model.set_stress(original_stress)
555. return losses
558. def train_with_stress_schedule(model: StressAwareNetwork, epochs: int, lr: float,
559. initial_stress: float, final_stress: float = 0.0,
560. pruning_manager: PruningManager = None,
561. verbose: bool = False, print_interval: int = 20) -> List[float]:
562. """Train with gradually reducing internal stress (SSRI-like)."""
563. optimizer = optim.Adam(model.parameters(), lr=lr)
564. loss_fn = nn.CrossEntropyLoss()
565. losses = []
567. for epoch in range(epochs):
568. model.reduce_stress_gradually(epoch, epochs, initial_stress, final_stress)
569. model.train()
570. epoch_loss = 0.0
572. for x, y in train_loader:
573. x, y = x.to(DEVICE), y.to(DEVICE)
574. optimizer.zero_grad()
575. loss = loss_fn(model(x), y)
576. loss.backward()
577. optimizer.step()
578. if pruning_manager:
579. pruning_manager.apply_masks()
580. epoch_loss += loss.item()
582. losses.append(epoch_loss / len(train_loader))
583. if verbose and (epoch + 1) % print_interval == 0:
584. print(f" SSRI epoch {epoch+1}/{epochs}, stress: {model.stress_level:.3f}, loss: {losses[-1]:.4f}")
586. model.set_stress(0.0)
587. return losses
590. # ============================================================================
591. # EVALUATION FUNCTIONS
592. # ============================================================================
593. def evaluate(model: StressAwareNetwork, loader: DataLoader,
594. input_noise: float = 0.0, internal_stress: float = 0.0) -> float:
595. """Evaluate model accuracy."""
596. model.eval()
597. model.set_stress(internal_stress)
598. correct, total = 0, 0
600. with torch.no_grad():
601. for x, y in loader:
602. x, y = x.to(DEVICE), y.to(DEVICE)
603. if input_noise > 0:
604. x = x + torch.randn_like(x) * input_noise
605. correct += (model(x).argmax(dim=1) == y).sum().item()
606. total += y.size(0)
608. model.set_stress(0.0)
609. return 100.0 * correct / total
612. def evaluate_with_neurosteroid(model: StressAwareNetwork, loader: DataLoader,
613. input_noise: float = 0.0, internal_stress: float = 0.0) -> float:
614. """Evaluate with neurosteroid modulation ACTIVE (inhibition settings preserved)."""
615. model.eval()
616. model.set_stress(internal_stress)
617. correct, total = 0, 0
619. with torch.no_grad():
620. for x, y in loader:
621. x, y = x.to(DEVICE), y.to(DEVICE)
622. if input_noise > 0:
623. x = x + torch.randn_like(x) * input_noise
624. correct += (model(x).argmax(dim=1) == y).sum().item()
625. total += y.size(0)
627. model.set_stress(0.0)
628. return 100.0 * correct / total
631. # ============================================================================
632. # TREATMENT PROTOCOLS
633. # ============================================================================
634. def ketamine_treatment(model: StressAwareNetwork, pruning_mgr: PruningManager,
635. regrow_fraction: float = None, consolidation_epochs: int = None,
636. verbose: bool = True) -> Dict:
637. """
638. KETAMINE-LIKE TREATMENT: Gradient-guided synaptogenesis.
640. Biological model:
641. - NMDA antagonism → BDNF release → mTOR activation → new spine formation
642. - Activity-dependent targeting of new synapses
643. - Brief consolidation to strengthen useful connections
645. Key feature: ADDS NEW SYNAPSES (reduces sparsity)
646. """
647. if regrow_fraction is None:
648. regrow_fraction = CONFIG['comparison_ketamine_regrow']
649. if consolidation_epochs is None:
650. consolidation_epochs = CONFIG['comparison_ketamine_epochs']
652. if verbose:
653. print(f"\n KETAMINE-LIKE TREATMENT:")
654. print(f" Regrowth fraction: {regrow_fraction*100:.0f}%")
655. print(f" Consolidation: {consolidation_epochs} epochs")
656. print(f" Estimating gradient importance...")
658. regrow_stats = pruning_mgr.gradient_guided_regrow(regrow_fraction=regrow_fraction)
659. total_regrown = sum(s['regrown'] for s in regrow_stats.values())
661. if verbose:
662. print(f" Restored {total_regrown:,} synapses")
663. print(f" Consolidating new synapses...")
665. consolidation_losses = train(model, epochs=consolidation_epochs,
666. lr=CONFIG['finetune_lr'], pruning_manager=pruning_mgr)
668. final_sparsity = pruning_mgr.get_sparsity()
669. if verbose:
670. print(f" Final sparsity: {final_sparsity*100:.1f}%")
672. return {'regrow_stats': regrow_stats, 'final_sparsity': final_sparsity}
675. def ssri_treatment(model: StressAwareNetwork, pruning_mgr: PruningManager,
676. epochs: int = None, learning_rate: float = None,
677. initial_stress: float = None, verbose: bool = True,
678. print_interval: int = 25) -> Dict:
679. """
680. SSRI-LIKE TREATMENT: Gradual stabilization without structural changes.
682. Biological model:
683. - Increased synaptic serotonin → gradual receptor adaptations
684. - 5-HT1A autoreceptor desensitization over weeks
685. - Improved signal-to-noise in existing circuits
687. Key feature: NO NEW SYNAPSES (sparsity unchanged)
688. """
689. if epochs is None:
690. epochs = CONFIG['monoaminergic_epochs']
691. if learning_rate is None:
692. learning_rate = CONFIG['monoaminergic_lr']
693. if initial_stress is None:
694. initial_stress = CONFIG['monoaminergic_initial_stress']
696. if verbose:
697. print(f"\n SSRI-LIKE TREATMENT:")
698. print(f" Duration: {epochs} epochs (gradual)")
699. print(f" Learning rate: {learning_rate} (very low)")
700. print(f" Internal stress: {initial_stress} → 0.0")
701. print(f" Note: NO structural changes (fixed sparsity)")
703. initial_sparsity = pruning_mgr.get_sparsity()
705. losses = train_with_stress_schedule(model, epochs=epochs, lr=learning_rate,
706. initial_stress=initial_stress, final_stress=0.0,
707. pruning_manager=pruning_mgr, verbose=verbose,
708. print_interval=print_interval)
710. final_sparsity = pruning_mgr.get_sparsity()
711. if verbose:
712. print(f" Final sparsity: {final_sparsity*100:.1f}% (unchanged)")
714. return {'final_sparsity': final_sparsity, 'training_losses': losses}
717. def neurosteroid_treatment(model: StressAwareNetwork, pruning_mgr: PruningManager,
718. inhibition_strength: float = None, use_tanh: bool = None,
719. consolidation_epochs: int = None, verbose: bool = True) -> Dict:
720. """
721. NEUROSTEROID-LIKE TREATMENT: Enhanced tonic inhibition.
723. Biological model:
724. - Enhanced extrasynaptic GABA-A receptor activation
725. - Tonic (sustained) inhibition reduces network excitability
726. - Rapid onset (days, not weeks)
728. Key features:
729. - NO NEW SYNAPSES (sparsity unchanged)
730. - Works by DAMPING activity rather than building structure
731. - Medication-dependent (effects reverse when stopped)
732. """
733. if inhibition_strength is None:
734. inhibition_strength = CONFIG['neurosteroid_inhibition_strength']
735. if use_tanh is None:
736. use_tanh = CONFIG['neurosteroid_use_tanh']
737. if consolidation_epochs is None:
738. consolidation_epochs = CONFIG['neurosteroid_consolidation_epochs']
740. if verbose:
741. print(f"\n NEUROSTEROID-LIKE TREATMENT:")
742. print(f" Inhibition strength: {inhibition_strength} ({(1-inhibition_strength)*100:.0f}% damping)")
743. print(f" Bounded activation (tanh): {use_tanh}")
744. print(f" Consolidation: {consolidation_epochs} epochs")
745. print(f" Note: NO structural changes (fixed sparsity)")
747. # Apply tonic inhibition modulation
748. model.set_inhibition(inhibition_strength, use_tanh)
749. if verbose:
750. print(f" Applied tonic inhibition modulation...")
751. print(f" Adapting to new activity dynamics...")
753. consolidation_losses = train(model, epochs=consolidation_epochs,
754. lr=CONFIG['finetune_lr'], pruning_manager=pruning_mgr)
756. final_sparsity = pruning_mgr.get_sparsity()
757. if verbose:
758. print(f" Final sparsity: {final_sparsity*100:.1f}% (unchanged)")
760. return {'final_sparsity': final_sparsity, 'inhibition_strength': inhibition_strength,
761. 'use_tanh': use_tanh}
764. # ============================================================================
765. # ISO-DOSE PARAMETER SWEEP FUNCTIONS
766. # ============================================================================
768. def clone_model_and_manager(
769. base_state_dict: Dict[str, torch.Tensor],
770. base_masks: Dict[str, torch.Tensor]
771. ) -> Tuple[StressAwareNetwork, PruningManager]:
772. """Clone model and pruning manager from saved states."""
773. model = StressAwareNetwork().to(DEVICE)
774. model.load_state_dict({k: v.clone() for k, v in base_state_dict.items()})
775. mgr = PruningManager(model)
776. mgr.masks = {k: v.clone() for k, v in base_masks.items()}
777. mgr.apply_masks()
778. return model, mgr
781. def run_ketamine_sweep(
782. base_state_dict: Dict[str, torch.Tensor],
783. base_masks: Dict[str, torch.Tensor],
784. untreated_combined: float,
785. regrow_fractions: List[float] = None,
786. verbose: bool = False
787. ) -> List[Dict[str, Any]]:
788. """
789. Sweep ketamine regrow_fraction and measure dose + outcomes.
791. Returns list of results with dose metrics and performance outcomes.
792. """
793. if regrow_fractions is None:
794. regrow_fractions = CONFIG['ketamine_regrow_sweep']
796. results = []
798. for regrow_frac in regrow_fractions:
799. model, mgr = clone_model_and_manager(base_state_dict, base_masks)
801. # Capture pre-treatment state
802. pre_state = {n: p.data.clone() for n, p in model.named_parameters() if 'weight' in n}
804. # Apply treatment
805. ketamine_treatment(model, mgr, regrow_fraction=regrow_frac,
806. consolidation_epochs=CONFIG['comparison_ketamine_epochs'],
807. verbose=False)
809. # Compute dose metrics
810. dose_metrics = compute_all_dose_metrics(pre_state, model)
812. # Evaluate acute performance
813. acute_clean = evaluate(model, clean_test_loader, 0.0, 0.0)
814. acute_standard = evaluate(model, test_loader, 0.0, 0.0)
815. acute_combined = evaluate(model, test_loader, 1.0, 0.5)
816. acute_extreme = evaluate(model, test_loader, 0.0, 2.5)
818. # Relapse simulation
819. pre_relapse_combined = acute_combined
820. mgr.secondary_prune(fraction=CONFIG['relapse_prune_fraction'])
821. post_relapse_combined = evaluate(model, test_loader, 1.0, 0.5)
822. relapse_drop = pre_relapse_combined - post_relapse_combined
824. improvement = acute_combined - untreated_combined
826. results.append({
827. 'treatment': 'ketamine',
828. 'param_name': 'regrow_fraction',
829. 'param_value': regrow_frac,
830. 'dose': dose_metrics,
831. 'sparsity': mgr.get_sparsity() * 100,
832. 'acute_clean': acute_clean,
833. 'acute_standard': acute_standard,
834. 'acute_combined': acute_combined,
835. 'acute_extreme': acute_extreme,
836. 'improvement': improvement,
837. 'relapse_drop': relapse_drop,
838. 'post_relapse_combined': post_relapse_combined
839. })
841. if verbose:
842. print(f" regrow_frac={regrow_frac:.2f}: dose={dose_metrics.l1_norm:.6f}, "
843. f"combined={acute_combined:.1f}%, relapse_drop={relapse_drop:.1f}%")
845. return results
848. def run_ssri_sweep(
849. base_state_dict: Dict[str, torch.Tensor],
850. base_masks: Dict[str, torch.Tensor],
851. untreated_combined: float,
852. epochs_list: List[int] = None,
853. lr_list: List[float] = None,
854. verbose: bool = False
855. ) -> List[Dict[str, Any]]:
856. """
857. Sweep SSRI epochs and learning rate, measure dose + outcomes.
859. Returns list of results with dose metrics and performance outcomes.
860. """
861. if epochs_list is None:
862. epochs_list = CONFIG['ssri_epochs_sweep']
863. if lr_list is None:
864. lr_list = [CONFIG['monoaminergic_lr']]
866. results = []
868. for epochs in epochs_list:
869. for lr in lr_list:
870. model, mgr = clone_model_and_manager(base_state_dict, base_masks)
872. # Capture pre-treatment state
873. pre_state = {n: p.data.clone() for n, p in model.named_parameters() if 'weight' in n}
875. # Apply treatment
876. ssri_treatment(model, mgr, epochs=epochs, learning_rate=lr,
877. initial_stress=CONFIG['monoaminergic_initial_stress'],
878. verbose=False)
880. # Compute dose metrics
881. dose_metrics = compute_all_dose_metrics(pre_state, model)
883. # Evaluate acute performance
884. acute_clean = evaluate(model, clean_test_loader, 0.0, 0.0)
885. acute_standard = evaluate(model, test_loader, 0.0, 0.0)
886. acute_combined = evaluate(model, test_loader, 1.0, 0.5)
887. acute_extreme = evaluate(model, test_loader, 0.0, 2.5)
889. # Relapse simulation
890. pre_relapse_combined = acute_combined
891. mgr.secondary_prune(fraction=CONFIG['relapse_prune_fraction'])
892. post_relapse_combined = evaluate(model, test_loader, 1.0, 0.5)
893. relapse_drop = pre_relapse_combined - post_relapse_combined
895. improvement = acute_combined - untreated_combined
897. results.append({
898. 'treatment': 'ssri',
899. 'param_name': 'epochs',
900. 'param_value': epochs,
901. 'lr': lr,
902. 'dose': dose_metrics,
903. 'sparsity': mgr.get_sparsity() * 100,
904. 'acute_clean': acute_clean,
905. 'acute_standard': acute_standard,
906. 'acute_combined': acute_combined,
907. 'acute_extreme': acute_extreme,
908. 'improvement': improvement,
909. 'relapse_drop': relapse_drop,
910. 'post_relapse_combined': post_relapse_combined
911. })
913. if verbose:
914. print(f" epochs={epochs}, lr={lr:.0e}: dose={dose_metrics.l1_norm:.6f}, "
915. f"combined={acute_combined:.1f}%, relapse_drop={relapse_drop:.1f}%")
917. return results
920. def run_neurosteroid_sweep(
921. base_state_dict: Dict[str, torch.Tensor],
922. base_masks: Dict[str, torch.Tensor],
923. untreated_combined: float,
924. strength_list: List[float] = None,
925. verbose: bool = False
926. ) -> List[Dict[str, Any]]:
927. """
928. Sweep neurosteroid inhibition strength, measure dose + outcomes.
930. Returns list of results with dose metrics and performance outcomes.
931. """
932. if strength_list is None:
933. strength_list = CONFIG['neurosteroid_strength_sweep']
935. results = []
937. for strength in strength_list:
938. model, mgr = clone_model_and_manager(base_state_dict, base_masks)
940. # Capture pre-treatment state
941. pre_state = {n: p.data.clone() for n, p in model.named_parameters() if 'weight' in n}
943. # Apply treatment
944. neurosteroid_treatment(model, mgr, inhibition_strength=strength,
945. use_tanh=CONFIG['neurosteroid_use_tanh'],
946. consolidation_epochs=CONFIG['neurosteroid_consolidation_epochs'],
947. verbose=False)
949. # Compute dose metrics
950. dose_metrics = compute_all_dose_metrics(pre_state, model)
952. # Evaluate acute performance WITH modulation active
953. acute_clean = evaluate_with_neurosteroid(model, clean_test_loader, 0.0, 0.0)
954. acute_standard = evaluate_with_neurosteroid(model, test_loader, 0.0, 0.0)
955. acute_combined = evaluate_with_neurosteroid(model, test_loader, 1.0, 0.5)
956. acute_extreme = evaluate_with_neurosteroid(model, test_loader, 0.0, 2.5)
958. # Evaluate OFF medication
959. model.set_inhibition(1.0, False)
960. off_med_combined = evaluate(model, test_loader, 1.0, 0.5)
961. off_med_extreme = evaluate(model, test_loader, 0.0, 2.5)
962. off_med_reversal = off_med_combined - acute_combined
964. # Restore modulation for relapse test
965. model.set_inhibition(strength, CONFIG['neurosteroid_use_tanh'])
967. # Relapse simulation (with modulation active)
968. pre_relapse_combined = acute_combined
969. mgr.secondary_prune(fraction=CONFIG['relapse_prune_fraction'])
970. post_relapse_combined = evaluate_with_neurosteroid(model, test_loader, 1.0, 0.5)
971. relapse_drop = pre_relapse_combined - post_relapse_combined
973. improvement = acute_combined - untreated_combined
975. results.append({
976. 'treatment': 'neurosteroid',
977. 'param_name': 'strength',
978. 'param_value': strength,
979. 'dose': dose_metrics,
980. 'sparsity': mgr.get_sparsity() * 100,
981. 'acute_clean': acute_clean,
982. 'acute_standard': acute_standard,
983. 'acute_combined': acute_combined,
984. 'acute_extreme': acute_extreme,
985. 'improvement': improvement,
986. 'off_med_combined': off_med_combined,
987. 'off_med_extreme': off_med_extreme,
988. 'off_med_reversal': off_med_reversal,
989. 'relapse_drop': relapse_drop,
990. 'post_relapse_combined': post_relapse_combined
991. })
993. if verbose:
994. print(f" strength={strength:.2f}: dose={dose_metrics.l1_norm:.6f}, "
995. f"combined={acute_combined:.1f}%, off_med={off_med_combined:.1f}%, "
996. f"relapse_drop={relapse_drop:.1f}%")
998. return results
1001. def find_iso_dose_match(
1002. sweep_results: List[Dict[str, Any]],
1003. target_dose: float,
1004. tolerance: float = None
1005. ) -> Optional[Dict[str, Any]]:
1006. """
1007. Find parameter configuration closest to target dose.
1009. Returns the result with dose closest to target, or None if no results.
1010. """
1011. if tolerance is None:
1012. tolerance = CONFIG['iso_dose_tolerance']
1014. if not sweep_results:
1015. return None
1017. best_match = None
1018. best_diff = float('inf')
1020. for result in sweep_results:
1021. dose = result['dose'].l1_norm
1022. diff = abs(dose - target_dose)
1023. if diff < best_diff:
1024. best_diff = diff
1025. best_match = result
1027. return best_match
1030. def compute_efficiency(improvement: float, dose: float) -> float:
1031. """Compute treatment efficiency: improvement per unit dose."""
1032. return improvement / (dose + 1e-8)
1035. # ============================================================================
1036. # ISO-DOSE COMPARISON EXPERIMENT
1037. # ============================================================================
1039. def run_iso_dose_comparison_experiment(
1040. base_state_dict: Dict[str, torch.Tensor],
1041. base_masks: Dict[str, torch.Tensor],
1042. untreated_results: Dict[str, Any]
1043. ) -> Dict[str, Any]:
1044. """
1045. Run iso-dose comparison across all three treatment mechanisms.
1047. Sweeps parameters for each treatment, measures dose (L1 weight change norm),
1048. and compares outcomes at matched dose levels.
1049. """
1050. print("\n" + "=" * 80)
1051. print(" ISO-DOSE FAIR COMPARISON EXPERIMENT")
1052. print("=" * 80)
1054. print("""
1055. ISO-DOSE COMPARISON METHODOLOGY:
1057. ┌────────────────────────────────────────────────────────────────────────────┐
1058. │ DOSE METRIC: L1 weight change norm (normalized per parameter) │
1059. │ │
1060. │ This provides a mechanism-agnostic measure of "how much the network │
1061. │ changed" regardless of whether changes came from: │
1062. │ - Structural regrowth (ketamine) │
1063. │ - Gradual weight refinement (SSRI) │
1064. │ - Consolidation under modulation (neurosteroid) │
1065. │ │
1066. │ EFFICIENCY = (Performance Improvement) / (Dose) │
1067. │ Higher efficiency = better outcome per unit of network change │
1068. └────────────────────────────────────────────────────────────────────────────┘
1069. """)
1071. untreated_combined = untreated_results['combined']
1073. results = {
1074. 'sweeps': {},
1075. 'iso_dose_comparisons': {},
1076. 'efficiency_analysis': {}
1077. }
1079. # ========================================================================
1080. # PHASE 1: Parameter Sweeps
1081. # ========================================================================
1082. print("-" * 70)
1083. print(" PHASE 1: Parameter Sweeps (Measuring Dose-Response)")
1084. print("-" * 70)
1086. print("\n [KETAMINE] Sweeping regrow_fraction...")
1087. print(f" Testing {len(CONFIG['ketamine_regrow_sweep'])} configurations...")
1088. ketamine_results = run_ketamine_sweep(
1089. base_state_dict, base_masks, untreated_combined, verbose=True
1090. )
1091. results['sweeps']['ketamine'] = ketamine_results
1092. print(f" Completed {len(ketamine_results)} configurations")
1094. print("\n [SSRI] Sweeping epochs...")
1095. print(f" Testing {len(CONFIG['ssri_epochs_sweep'])} configurations...")
1096. ssri_results = run_ssri_sweep(
1097. base_state_dict, base_masks, untreated_combined, verbose=True
1098. )
1099. results['sweeps']['ssri'] = ssri_results
1100. print(f" Completed {len(ssri_results)} configurations")
1102. print("\n [NEUROSTEROID] Sweeping inhibition strength...")
1103. print(f" Testing {len(CONFIG['neurosteroid_strength_sweep'])} configurations...")
1104. neurosteroid_results = run_neurosteroid_sweep(
1105. base_state_dict, base_masks, untreated_combined, verbose=True
1106. )
1107. results['sweeps']['neurosteroid'] = neurosteroid_results
1108. print(f" Completed {len(neurosteroid_results)} configurations")
1110. # ========================================================================
1111. # PHASE 2: Dose-Response Analysis
1112. # ========================================================================
1113. print("\n" + "-" * 70)
1114. print(" PHASE 2: Dose-Response Curves")
1115. print("-" * 70)
1117. print("\n KETAMINE DOSE-RESPONSE:")
1118. print(f" {'regrow_frac':>12} {'L1 Dose':>12} {'L2 Dose':>12} {'Turnover':>10} "
1119. f"{'Combined':>10} {'Improve':>10} {'Relapse':>10}")
1120. print(" " + "-" * 88)
1121. for r in ketamine_results:
1122. print(f" {r['param_value']:>12.2f} {r['dose'].l1_norm:>12.6f} {r['dose'].l2_norm:>12.6f} "
1123. f"{r['dose'].synaptic_turnover:>10.4f} {r['acute_combined']:>9.1f}% "
1124. f"{r['improvement']:>+9.1f}% {r['relapse_drop']:>9.1f}%")
1126. print("\n SSRI DOSE-RESPONSE:")
1127. print(f" {'epochs':>12} {'L1 Dose':>12} {'L2 Dose':>12} {'Turnover':>10} "
1128. f"{'Combined':>10} {'Improve':>10} {'Relapse':>10}")
1129. print(" " + "-" * 88)
1130. for r in ssri_results:
1131. print(f" {r['param_value']:>12} {r['dose'].l1_norm:>12.6f} {r['dose'].l2_norm:>12.6f} "
1132. f"{r['dose'].synaptic_turnover:>10.4f} {r['acute_combined']:>9.1f}% "
1133. f"{r['improvement']:>+9.1f}% {r['relapse_drop']:>9.1f}%")
1135. print("\n NEUROSTEROID DOSE-RESPONSE:")
1136. print(f" {'strength':>12} {'L1 Dose':>12} {'L2 Dose':>12} {'Turnover':>10} "
1137. f"{'Combined':>10} {'Off-Med':>10} {'Relapse':>10}")
1138. print(" " + "-" * 88)
1139. for r in neurosteroid_results:
1140. print(f" {r['param_value']:>12.2f} {r['dose'].l1_norm:>12.6f} {r['dose'].l2_norm:>12.6f} "
1141. f"{r['dose'].synaptic_turnover:>10.4f} {r['acute_combined']:>9.1f}% "
1142. f"{r['off_med_combined']:>9.1f}% {r['relapse_drop']:>9.1f}%")
1144. # ========================================================================
1145. # PHASE 3: Determine Dose Range for Iso-Dose Matching
1146. # ========================================================================
1147. print("\n" + "-" * 70)
1148. print(" PHASE 3: Iso-Dose Matching")
1149. print("-" * 70)
1151. all_doses = []
1152. for r in ketamine_results:
1153. all_doses.append(('ketamine', r['param_value'], r['dose'].l1_norm))
1154. for r in ssri_results:
1155. all_doses.append(('ssri', r['param_value'], r['dose'].l1_norm))
1156. for r in neurosteroid_results:
1157. all_doses.append(('neurosteroid', r['param_value'], r['dose'].l1_norm))
1159. dose_values = [d[2] for d in all_doses]
1160. dose_min, dose_max = min(dose_values), max(dose_values)
1162. print(f"\n Observed dose range across all treatments:")
1163. print(f" Minimum dose: {dose_min:.6f}")
1164. print(f" Maximum dose: {dose_max:.6f}")
1166. # Find overlapping dose range
1167. ket_doses = [r['dose'].l1_norm for r in ketamine_results]
1168. ssri_doses = [r['dose'].l1_norm for r in ssri_results]
1169. neuro_doses = [r['dose'].l1_norm for r in neurosteroid_results]
1171. overlap_min = max(min(ket_doses), min(ssri_doses), min(neuro_doses))
1172. overlap_max = min(max(ket_doses), max(ssri_doses), max(neuro_doses))
1174. print(f"\n Overlapping dose range (for fair comparison):")
1175. print(f" Overlap minimum: {overlap_min:.6f}")
1176. print(f" Overlap maximum: {overlap_max:.6f}")
1178. # Generate target doses within overlap
1179. if overlap_max > overlap_min:
1180. target_doses = np.linspace(overlap_min, overlap_max, 5).tolist()
1181. else:
1182. # If no overlap, use percentiles of all doses
1183. target_doses = [np.percentile(dose_values, p) for p in [20, 40, 60, 80]]
1185. print(f"\n Target doses for iso-dose comparison:")
1186. for i, td in enumerate(target_doses):
1187. print(f" Level {i+1}: {td:.6f}")
1189. # ========================================================================
1190. # PHASE 4: Iso-Dose Matched Comparisons
1191. # ========================================================================
1192. print("\n" + "-" * 70)
1193. print(" PHASE 4: Iso-Dose Matched Comparisons")
1194. print("-" * 70)
1196. for i, target_dose in enumerate(target_doses):
1197. print(f"\n ISO-DOSE LEVEL {i+1}: Target Dose = {target_dose:.6f}")
1198. print(" " + "=" * 75)
1200. ket_match = find_iso_dose_match(ketamine_results, target_dose)
1201. ssri_match = find_iso_dose_match(ssri_results, target_dose)
1202. neuro_match = find_iso_dose_match(neurosteroid_results, target_dose)
1204. iso_comparison = {
1205. 'target_dose': target_dose,
1206. 'ketamine': ket_match,
1207. 'ssri': ssri_match,
1208. 'neurosteroid': neuro_match
1209. }
1210. results['iso_dose_comparisons'][f'level_{i+1}'] = iso_comparison
1212. print(f"\n {'Treatment':<15} {'Parameter':<18} {'Actual Dose':>12} {'Dose Diff':>12} "
1213. f"{'Combined':>10} {'Improve':>10} {'Relapse':>10}")
1214. print(" " + "-" * 95)
1216. for name, match in [('Ketamine', ket_match), ('SSRI', ssri_match), ('Neurosteroid', neuro_match)]:
1217. if match:
1218. param_str = f"{match['param_name']}={match['param_value']}"
1219. actual_dose = match['dose'].l1_norm
1220. dose_diff = actual_dose - target_dose
1221. print(f" {name:<15} {param_str:<18} {actual_dose:>12.6f} {dose_diff:>+12.6f} "
1222. f"{match['acute_combined']:>9.1f}% {match['improvement']:>+9.1f}% "
1223. f"{match['relapse_drop']:>9.1f}%")
1224. else:
1225. print(f" {name:<15} {'N/A':<18} {'N/A':>12} {'N/A':>12} {'N/A':>10} {'N/A':>10} {'N/A':>10}")
1227. # Determine best treatment at this dose level
1228. valid_matches = [(n, m) for n, m in [('Ketamine', ket_match), ('SSRI', ssri_match),
1229. ('Neurosteroid', neuro_match)] if m]
1230. if valid_matches:
1231. best_combined = max(valid_matches, key=lambda x: x[1]['acute_combined'])
1232. best_relapse = min(valid_matches, key=lambda x: x[1]['relapse_drop'])
1234. print(f"\n At this dose level:")
1235. print(f" Best acute performance: {best_combined[0]} ({best_combined[1]['acute_combined']:.1f}%)")
1236. print(f" Best relapse resistance: {best_relapse[0]} (drop: {best_relapse[1]['relapse_drop']:.1f}%)")
1238. # ========================================================================
1239. # PHASE 5: Efficiency Analysis
1240. # ========================================================================
1241. print("\n" + "-" * 70)
1242. print(" PHASE 5: Treatment Efficiency Analysis")
1243. print("-" * 70)
1245. print("\n EFFICIENCY = (Performance Improvement) / (L1 Dose)")
1246. print(" Higher efficiency = better outcome per unit of network change")
1248. print("\n KETAMINE EFFICIENCY:")
1249. print(f" {'regrow_frac':>12} {'Dose':>12} {'Improvement':>12} {'Efficiency':>12}")
1250. print(" " + "-" * 52)
1251. ket_efficiencies = []
1252. for r in ketamine_results:
1253. eff = compute_efficiency(r['improvement'], r['dose'].l1_norm)
1254. ket_efficiencies.append(eff)
1255. print(f" {r['param_value']:>12.2f} {r['dose'].l1_norm:>12.6f} {r['improvement']:>+11.1f}% {eff:>12.2f}")
1257. print("\n SSRI EFFICIENCY:")
1258. print(f" {'epochs':>12} {'Dose':>12} {'Improvement':>12} {'Efficiency':>12}")
1259. print(" " + "-" * 52)
1260. ssri_efficiencies = []
1261. for r in ssri_results:
1262. eff = compute_efficiency(r['improvement'], r['dose'].l1_norm)
1263. ssri_efficiencies.append(eff)
1264. print(f" {r['param_value']:>12} {r['dose'].l1_norm:>12.6f} {r['improvement']:>+11.1f}% {eff:>12.2f}")
1266. print("\n NEUROSTEROID EFFICIENCY:")
1267. print(f" {'strength':>12} {'Dose':>12} {'Improvement':>12} {'Efficiency':>12}")
1268. print(" " + "-" * 52)
1269. neuro_efficiencies = []
1270. for r in neurosteroid_results:
1271. eff = compute_efficiency(r['improvement'], r['dose'].l1_norm)
1272. neuro_efficiencies.append(eff)
1273. print(f" {r['param_value']:>12.2f} {r['dose'].l1_norm:>12.6f} {r['improvement']:>+11.1f}% {eff:>12.2f}")
1275. # Store efficiency results
1276. results['efficiency_analysis'] = {
1277. 'ketamine': {
1278. 'max_efficiency': max(ket_efficiencies) if ket_efficiencies else 0,
1279. 'mean_efficiency': np.mean(ket_efficiencies) if ket_efficiencies else 0,
1280. 'best_config': ketamine_results[np.argmax(ket_efficiencies)]['param_value'] if ket_efficiencies else None
1281. },
1282. 'ssri': {
1283. 'max_efficiency': max(ssri_efficiencies) if ssri_efficiencies else 0,
1284. 'mean_efficiency': np.mean(ssri_efficiencies) if ssri_efficiencies else 0,
1285. 'best_config': ssri_results[np.argmax(ssri_efficiencies)]['param_value'] if ssri_efficiencies else None
1286. },
1287. 'neurosteroid': {
1288. 'max_efficiency': max(neuro_efficiencies) if neuro_efficiencies else 0,
1289. 'mean_efficiency': np.mean(neuro_efficiencies) if neuro_efficiencies else 0,
1290. 'best_config': neurosteroid_results[np.argmax(neuro_efficiencies)]['param_value'] if neuro_efficiencies else None
1291. }
1292. }
1294. # ========================================================================
1295. # PHASE 6: Summary Statistics
1296. # ========================================================================
1297. print("\n" + "-" * 70)
1298. print(" PHASE 6: Summary Statistics")
1299. print("-" * 70)
1301. def compute_sweep_stats(sweep_results, treatment_name):
1302. doses = [r['dose'].l1_norm for r in sweep_results]
1303. turnovers = [r['dose'].synaptic_turnover for r in sweep_results]
1304. improvements = [r['improvement'] for r in sweep_results]
1305. relapse_drops = [r['relapse_drop'] for r in sweep_results]
1306. efficiencies = [compute_efficiency(r['improvement'], r['dose'].l1_norm) for r in sweep_results]
1308. return {
1309. 'treatment': treatment_name,
1310. 'n_configs': len(sweep_results),
1311. 'dose_range': (min(doses), max(doses)),
1312. 'dose_mean': np.mean(doses),
1313. 'turnover_range': (min(turnovers), max(turnovers)),
1314. 'best_improvement': max(improvements),
1315. 'worst_improvement': min(improvements),
1316. 'best_relapse': min(relapse_drops),
1317. 'worst_relapse': max(relapse_drops),
1318. 'max_efficiency': max(efficiencies),
1319. 'mean_efficiency': np.mean(efficiencies)
1320. }
1322. ket_stats = compute_sweep_stats(ketamine_results, 'Ketamine')
1323. ssri_stats = compute_sweep_stats(ssri_results, 'SSRI')
1324. neuro_stats = compute_sweep_stats(neurosteroid_results, 'Neurosteroid')
1326. results['summary_stats'] = {
1327. 'ketamine': ket_stats,
1328. 'ssri': ssri_stats,
1329. 'neurosteroid': neuro_stats
1330. }
1332. print("\n TREATMENT SUMMARY ACROSS ALL CONFIGURATIONS:")
1333. print(f"\n {'Metric':<25} {'Ketamine':>18} {'SSRI':>18} {'Neurosteroid':>18}")
1334. print(" " + "-" * 80)
1336. print(f" {'Configurations tested':<25} {ket_stats['n_configs']:>18} "
1337. f"{ssri_stats['n_configs']:>18} {neuro_stats['n_configs']:>18}")
1339. print(f" {'Dose range (L1)':<25} {ket_stats['dose_range'][0]:.4f}-{ket_stats['dose_range'][1]:.4f}"
1340. f" {ssri_stats['dose_range'][0]:.4f}-{ssri_stats['dose_range'][1]:.4f}"
1341. f" {neuro_stats['dose_range'][0]:.4f}-{neuro_stats['dose_range'][1]:.4f}")
1343. print(f" {'Mean dose':<25} {ket_stats['dose_mean']:>18.6f} "
1344. f"{ssri_stats['dose_mean']:>18.6f} {neuro_stats['dose_mean']:>18.6f}")
1346. print(f" {'Best improvement':<25} {ket_stats['best_improvement']:>+17.1f}% "
1347. f"{ssri_stats['best_improvement']:>+17.1f}% {neuro_stats['best_improvement']:>+17.1f}%")
1349. print(f" {'Best relapse resistance':<25} {ket_stats['best_relapse']:>17.1f}% "
1350. f"{ssri_stats['best_relapse']:>17.1f}% {neuro_stats['best_relapse']:>17.1f}%")
1352. print(f" {'Max efficiency':<25} {ket_stats['max_efficiency']:>18.2f} "
1353. f"{ssri_stats['max_efficiency']:>18.2f} {neuro_stats['max_efficiency']:>18.2f}")
1355. print(f" {'Mean efficiency':<25} {ket_stats['mean_efficiency']:>18.2f} "
1356. f"{ssri_stats['mean_efficiency']:>18.2f} {neuro_stats['mean_efficiency']:>18.2f}")
1358. # ========================================================================
1359. # PHASE 7: Detailed Iso-Dose Comparison Tables
1360. # ========================================================================
1361. print("\n" + "=" * 80)
1362. print(" DETAILED ISO-DOSE COMPARISON RESULTS")
1363. print("=" * 80)
1365. for level_key, comparison in results['iso_dose_comparisons'].items():
1366. target_dose = comparison['target_dose']
1367. print(f"\n {level_key.upper().replace('_', ' ')}: TARGET DOSE = {target_dose:.6f}")
1368. print(" " + "=" * 75)
1370. print(f"\n {'Treatment':<15} {'Parameter':<20} {'Actual Dose':>12} {'Turnover':>10} "
1371. f"{'ΔSparsity':>10}")
1372. print(" " + "-" * 75)
1374. for treatment_name in ['ketamine', 'ssri', 'neurosteroid']:
1375. match = comparison.get(treatment_name)
1376. if match:
1377. param_str = f"{match['param_name']}={match['param_value']}"
1378. d = match['dose']
1379. print(f" {treatment_name.capitalize():<15} {param_str:<20} {d.l1_norm:>12.6f} "
1380. f"{d.synaptic_turnover:>10.4f} {d.sparsity_change:>10.4f}")
1381. else:
1382. print(f" {treatment_name.capitalize():<15} {'N/A':<20} {'N/A':>12} {'N/A':>10} {'N/A':>10}")
1384. print(f"\n {'Treatment':<15} {'Clean':>10} {'Standard':>10} {'Combined':>10} "
1385. f"{'Extreme':>10} {'Improve':>10} {'Relapse':>10}")
1386. print(" " + "-" * 85)
1388. for treatment_name in ['ketamine', 'ssri', 'neurosteroid']:
1389. match = comparison.get(treatment_name)
1390. if match:
1391. print(f" {treatment_name.capitalize():<15} {match['acute_clean']:>9.1f}% "
1392. f"{match['acute_standard']:>9.1f}% {match['acute_combined']:>9.1f}% "
1393. f"{match['acute_extreme']:>9.1f}% {match['improvement']:>+9.1f}% "
1394. f"{match['relapse_drop']:>9.1f}%")
1395. else:
1396. print(f" {treatment_name.capitalize():<15} {'N/A':>10} {'N/A':>10} {'N/A':>10} "
1397. f"{'N/A':>10} {'N/A':>10} {'N/A':>10}")
1399. # Neurosteroid-specific: off-medication performance
1400. neuro_match = comparison.get('neurosteroid')
1401. if neuro_match and 'off_med_combined' in neuro_match:
1402. print(f"\n NEUROSTEROID OFF-MEDICATION:")
1403. print(f" Combined stress (on medication): {neuro_match['acute_combined']:.1f}%")
1404. print(f" Combined stress (off medication): {neuro_match['off_med_combined']:.1f}%")
1405. print(f" Performance reversal: {neuro_match['off_med_reversal']:+.1f}%")
1407. # ========================================================================
1408. # PHASE 8: Cross-Treatment Comparison at Each Dose Level
1409. # ========================================================================
1410. print("\n" + "=" * 80)
1411. print(" CROSS-TREATMENT RANKINGS AT EACH DOSE LEVEL")
1412. print("=" * 80)
1414. for level_key, comparison in results['iso_dose_comparisons'].items():
1415. target_dose = comparison['target_dose']
1416. print(f"\n {level_key.upper().replace('_', ' ')}: Dose ≈ {target_dose:.6f}")
1417. print(" " + "-" * 60)
1419. valid_treatments = []
1420. for treatment_name in ['ketamine', 'ssri', 'neurosteroid']:
1421. match = comparison.get(treatment_name)
1422. if match:
1423. valid_treatments.append({
1424. 'name': treatment_name.capitalize(),
1425. 'combined': match['acute_combined'],
1426. 'improvement': match['improvement'],
1427. 'relapse_drop': match['relapse_drop'],
1428. 'efficiency': compute_efficiency(match['improvement'], match['dose'].l1_norm)
1429. })
1431. if valid_treatments:
1432. # Rank by combined performance
1433. by_combined = sorted(valid_treatments, key=lambda x: x['combined'], reverse=True)
1434. print(f"\n Ranking by Combined Stress Performance:")
1435. for rank, t in enumerate(by_combined, 1):
1436. print(f" {rank}. {t['name']:<15} {t['combined']:.1f}%")
1438. # Rank by relapse resistance (lower is better)
1439. by_relapse = sorted(valid_treatments, key=lambda x: x['relapse_drop'])
1440. print(f"\n Ranking by Relapse Resistance (lower drop = better):")
1441. for rank, t in enumerate(by_relapse, 1):
1442. print(f" {rank}. {t['name']:<15} {t['relapse_drop']:.1f}% drop")
1444. # Rank by efficiency
1445. by_efficiency = sorted(valid_treatments, key=lambda x: x['efficiency'], reverse=True)
1446. print(f"\n Ranking by Efficiency (improvement per dose):")
1447. for rank, t in enumerate(by_efficiency, 1):
1448. print(f" {rank}. {t['name']:<15} {t['efficiency']:.2f}")
1450. return results
1453. # ============================================================================
1454. # MAIN EXPERIMENT
1455. # ============================================================================
1456. def run_multi_mechanism_experiment() -> Dict[str, Dict]:
1457. """
1458. Compare ketamine, SSRI, and neurosteroid treatment mechanisms.
1460. All treatments start from identical 95% sparse (depressed) networks.
1461. """
1462. print("\n" + "="*80)
1463. print(" MULTI-MECHANISM ANTIDEPRESSANT COMPARISON EXPERIMENT")
1464. print("="*80)
1466. print("""
1467. COMPARING THREE ANTIDEPRESSANT MECHANISMS:
1469. ┌─────────────────┬─────────────────────────────────────────────────────────┐
1470. │ Mechanism │ Key Feature │
1471. ├─────────────────┼─────────────────────────────────────────────────────────┤
1472. │ Ketamine │ Gradient-guided synaptogenesis (↑ density) │
1473. │ SSRI │ Gradual noise reduction (stabilizes existing weights) │
1474. │ Neurosteroid │ Tonic inhibition (damps activity, bounds firing) │
1475. └─────────────────┴─────────────────────────────────────────────────────────┘
1477. All treatments start from identical 95% sparse (depressed) networks.
1478. """)
1480. # ========================================================================
1481. # PREPARE BASE PRUNED MODEL
1482. # ========================================================================
1483. print("-"*70)
1484. print(" Preparing shared pruned baseline...")
1485. print("-"*70)
1487. base_model = StressAwareNetwork().to(DEVICE)
1488. print(f" Training full network ({CONFIG['baseline_epochs']} epochs)...")
1489. train(base_model, epochs=CONFIG['baseline_epochs'], lr=CONFIG['baseline_lr'])
1491. base_pruning_mgr = PruningManager(base_model)
1492. base_pruning_mgr.prune_by_magnitude(sparsity=CONFIG['prune_sparsity'], per_layer=True)
1494. initial_sparsity = base_pruning_mgr.get_sparsity()
1495. print(f" Pruned to {initial_sparsity*100:.1f}% sparse")
1497. # Evaluate untreated state
1498. print("\n UNTREATED PRUNED STATE:")
1499. untreated_results = {'sparsity': initial_sparsity * 100}
1500. untreated_results['clean'] = evaluate(base_model, clean_test_loader, 0.0, 0.0)
1501. untreated_results['standard'] = evaluate(base_model, test_loader, 0.0, 0.0)
1502. for stress_name, stress_level in CONFIG['extended_stress_levels'].items():
1503. untreated_results[f'stress_{stress_name}'] = evaluate(base_model, test_loader, 0.0, stress_level)
1504. untreated_results['combined'] = evaluate(base_model, test_loader, 1.0, 0.5)
1506. print(f" Clean: {untreated_results['clean']:.1f}%")
1507. print(f" Standard: {untreated_results['standard']:.1f}%")
1508. print(f" Combined stress: {untreated_results['combined']:.1f}%")
1509. print(f" Extreme stress: {untreated_results['stress_extreme']:.1f}%")
1511. # Save state for cloning
1512. base_state_dict = {k: v.clone() for k, v in base_model.state_dict().items()}
1513. base_masks = {k: v.clone() for k, v in base_pruning_mgr.masks.items()}
1515. results = {'untreated': untreated_results}
1517. # ========================================================================
1518. # TREATMENT 1: KETAMINE-LIKE
1519. # ========================================================================
1520. print("\n" + "="*70)
1521. print(" TREATMENT 1: KETAMINE-LIKE (Synaptogenesis)")
1522. print("="*70)
1524. ketamine_model = StressAwareNetwork().to(DEVICE)
1525. ketamine_model.load_state_dict(base_state_dict)
1526. ketamine_mgr = PruningManager(ketamine_model)
1527. ketamine_mgr.masks = {k: v.clone() for k, v in base_masks.items()}
1528. ketamine_mgr.apply_masks()
1530. ketamine_stats = ketamine_treatment(ketamine_model, ketamine_mgr,
1531. regrow_fraction=CONFIG['comparison_ketamine_regrow'],
1532. consolidation_epochs=CONFIG['comparison_ketamine_epochs'])
1534. print("\n POST-TREATMENT EVALUATION:")
1535. ketamine_results = {'sparsity': ketamine_mgr.get_sparsity() * 100}
1536. ketamine_results['clean'] = evaluate(ketamine_model, clean_test_loader, 0.0, 0.0)
1537. ketamine_results['standard'] = evaluate(ketamine_model, test_loader, 0.0, 0.0)
1538. for stress_name, stress_level in CONFIG['extended_stress_levels'].items():
1539. ketamine_results[f'stress_{stress_name}'] = evaluate(ketamine_model, test_loader, 0.0, stress_level)
1540. ketamine_results['combined'] = evaluate(ketamine_model, test_loader, 1.0, 0.5)
1542. print(f" Clean: {ketamine_results['clean']:.1f}%")
1543. print(f" Standard: {ketamine_results['standard']:.1f}%")
1544. print(f" Combined stress: {ketamine_results['combined']:.1f}%")
1545. print(f" Extreme stress: {ketamine_results['stress_extreme']:.1f}%")
1547. # Relapse simulation
1548. print("\n RELAPSE SIMULATION:")
1549. pre_relapse = ketamine_results['combined']
1550. pre_sparsity = ketamine_mgr.get_sparsity()
1551. target_sparsity = min(pre_sparsity + (1 - pre_sparsity) * 0.40, 0.99)
1552. ketamine_mgr.prune_by_magnitude(sparsity=target_sparsity, per_layer=True)
1553. ketamine_mgr.apply_masks()
1554. post_relapse = evaluate(ketamine_model, test_loader, 1.0, 0.5)
1555. ketamine_results['relapse_drop'] = pre_relapse - post_relapse
1556. print(f" Combined: {pre_relapse:.1f}% → {post_relapse:.1f}% (drop: {ketamine_results['relapse_drop']:.1f}%)")
1558. results['ketamine'] = ketamine_results
1560. # ========================================================================
1561. # TREATMENT 2: SSRI-LIKE
1562. # ========================================================================
1563. print("\n" + "="*70)
1564. print(" TREATMENT 2: SSRI-LIKE (Gradual Stabilization)")
1565. print("="*70)
1567. ssri_model = StressAwareNetwork().to(DEVICE)
1568. ssri_model.load_state_dict(base_state_dict)
1569. ssri_mgr = PruningManager(ssri_model)
1570. ssri_mgr.masks = {k: v.clone() for k, v in base_masks.items()}
1571. ssri_mgr.apply_masks()
1573. ssri_stats = ssri_treatment(ssri_model, ssri_mgr,
1574. epochs=CONFIG['comparison_ssri_epochs'],
1575. learning_rate=CONFIG['monoaminergic_lr'],
1576. initial_stress=CONFIG['monoaminergic_initial_stress'],
1577. print_interval=25)
1579. print("\n POST-TREATMENT EVALUATION:")
1580. ssri_results = {'sparsity': ssri_mgr.get_sparsity() * 100}
1581. ssri_results['clean'] = evaluate(ssri_model, clean_test_loader, 0.0, 0.0)
1582. ssri_results['standard'] = evaluate(ssri_model, test_loader, 0.0, 0.0)
1583. for stress_name, stress_level in CONFIG['extended_stress_levels'].items():
1584. ssri_results[f'stress_{stress_name}'] = evaluate(ssri_model, test_loader, 0.0, stress_level)
1585. ssri_results['combined'] = evaluate(ssri_model, test_loader, 1.0, 0.5)
1587. print(f" Clean: {ssri_results['clean']:.1f}%")
1588. print(f" Standard: {ssri_results['standard']:.1f}%")
1589. print(f" Combined stress: {ssri_results['combined']:.1f}%")
1590. print(f" Extreme stress: {ssri_results['stress_extreme']:.1f}%")
1592. # Relapse simulation
1593. print("\n RELAPSE SIMULATION:")
1594. pre_relapse = ssri_results['combined']
1595. pre_sparsity = ssri_mgr.get_sparsity()
1596. target_sparsity = min(pre_sparsity + (1 - pre_sparsity) * 0.40, 0.99)
1597. ssri_mgr.prune_by_magnitude(sparsity=target_sparsity, per_layer=True)
1598. ssri_mgr.apply_masks()
1599. post_relapse = evaluate(ssri_model, test_loader, 1.0, 0.5)
1600. ssri_results['relapse_drop'] = pre_relapse - post_relapse
1601. print(f" Combined: {pre_relapse:.1f}% → {post_relapse:.1f}% (drop: {ssri_results['relapse_drop']:.1f}%)")
1603. results['ssri'] = ssri_results
1605. # ========================================================================
1606. # TREATMENT 3: NEUROSTEROID-LIKE
1607. # ========================================================================
1608. print("\n" + "="*70)
1609. print(" TREATMENT 3: NEUROSTEROID-LIKE (Tonic Inhibition)")
1610. print("="*70)
1612. neuro_model = StressAwareNetwork().to(DEVICE)
1613. neuro_model.load_state_dict(base_state_dict)
1614. neuro_mgr = PruningManager(neuro_model)
1615. neuro_mgr.masks = {k: v.clone() for k, v in base_masks.items()}
1616. neuro_mgr.apply_masks()
1618. neuro_stats = neurosteroid_treatment(neuro_model, neuro_mgr,
1619. inhibition_strength=CONFIG['neurosteroid_inhibition_strength'],
1620. use_tanh=CONFIG['neurosteroid_use_tanh'],
1621. consolidation_epochs=CONFIG['neurosteroid_consolidation_epochs'])
1623. # Evaluate WITH modulation active (patient on medication)
1624. print("\n POST-TREATMENT EVALUATION (with modulation active):")
1625. neuro_results = {'sparsity': neuro_mgr.get_sparsity() * 100}
1626. neuro_results['clean'] = evaluate_with_neurosteroid(neuro_model, clean_test_loader, 0.0, 0.0)
1627. neuro_results['standard'] = evaluate_with_neurosteroid(neuro_model, test_loader, 0.0, 0.0)
1628. for stress_name, stress_level in CONFIG['extended_stress_levels'].items():
1629. neuro_results[f'stress_{stress_name}'] = evaluate_with_neurosteroid(neuro_model, test_loader, 0.0, stress_level)
1630. neuro_results['combined'] = evaluate_with_neurosteroid(neuro_model, test_loader, 1.0, 0.5)
1632. print(f" Clean: {neuro_results['clean']:.1f}%")
1633. print(f" Standard: {neuro_results['standard']:.1f}%")
1634. print(f" Combined stress: {neuro_results['combined']:.1f}%")
1635. print(f" Extreme stress: {neuro_results['stress_extreme']:.1f}%")
1637. # Test WITHOUT modulation (medication discontinued)
1638. print("\n EVALUATION WITHOUT MODULATION (medication discontinued):")
1639. neuro_model.set_inhibition(1.0, False)
1640. off_med_combined = evaluate(neuro_model, test_loader, 1.0, 0.5)
1641. off_med_extreme = evaluate(neuro_model, test_loader, 0.0, 2.5)
1642. print(f" Combined stress: {off_med_combined:.1f}%")
1643. print(f" Extreme stress: {off_med_extreme:.1f}%")
1644. neuro_results['off_medication_combined'] = off_med_combined
1645. neuro_results['off_medication_extreme'] = off_med_extreme
1647. # Restore modulation for relapse test
1648. neuro_model.set_inhibition(CONFIG['neurosteroid_inhibition_strength'],
1649. CONFIG['neurosteroid_use_tanh'])
1651. # Relapse simulation
1652. print("\n RELAPSE SIMULATION (with modulation active):")
1653. pre_relapse = neuro_results['combined']
1654. pre_sparsity = neuro_mgr.get_sparsity()
1655. target_sparsity = min(pre_sparsity + (1 - pre_sparsity) * 0.40, 0.99)
1656. neuro_mgr.prune_by_magnitude(sparsity=target_sparsity, per_layer=True)
1657. neuro_mgr.apply_masks()
1658. post_relapse = evaluate_with_neurosteroid(neuro_model, test_loader, 1.0, 0.5)
1659. neuro_results['relapse_drop'] = pre_relapse - post_relapse
1660. print(f" Combined: {pre_relapse:.1f}% → {post_relapse:.1f}% (drop: {neuro_results['relapse_drop']:.1f}%)")
1662. results['neurosteroid'] = neuro_results
1664. # ========================================================================
1665. # COMPREHENSIVE COMPARISON
1666. # ========================================================================
1667. print("\n" + "="*80)
1668. print(" COMPREHENSIVE COMPARISON: ALL TREATMENTS")
1669. print("="*80)
1671. treatments = ['untreated', 'ketamine', 'ssri', 'neurosteroid']
1672. labels = {'untreated': 'Untreated (pruned)', 'ketamine': 'Ketamine-like',
1673. 'ssri': 'SSRI-like', 'neurosteroid': 'Neurosteroid-like'}
1675. print(f"\n {'Treatment':<22} {'Sparsity':>10} {'Clean':>8} {'Standard':>10} "
1676. f"{'Combined':>10} {'Extreme':>10} {'Relapse':>10}")
1677. print(" " + "-"*85)
1679. for t in treatments:
1680. r = results[t]
1681. relapse = r.get('relapse_drop', 'N/A')
1682. relapse_str = f"{relapse:.1f}%" if isinstance(relapse, float) else relapse
1683. print(f" {labels[t]:<22} {r['sparsity']:>9.1f}% {r['clean']:>7.1f}% "
1684. f"{r['standard']:>9.1f}% {r['combined']:>9.1f}% "
1685. f"{r['stress_extreme']:>9.1f}% {relapse_str:>10}")
1687. # Stress resilience profile
1688. print("\n STRESS RESILIENCE PROFILE:")
1689. print(f"\n {'Treatment':<22} {'None':>8} {'Moderate':>10} {'High':>8} {'Severe':>8} {'Extreme':>10}")
1690. print(" " + "-"*70)
1692. for t in treatments:
1693. r = results[t]
1694. print(f" {labels[t]:<22} {r['stress_none']:>7.1f}% {r['stress_moderate']:>9.1f}% "
1695. f"{r['stress_high']:>7.1f}% {r['stress_severe']:>7.1f}% {r['stress_extreme']:>9.1f}%")
1697. # ========================================================================
1698. # ANALYSIS
1699. # ========================================================================
1700. print("\n" + "-"*80)
1701. print(" ANALYSIS")
1702. print("-"*80)
1704. ket, ssri, neuro = results['ketamine'], results['ssri'], results['neurosteroid']
1705. untreated = results['untreated']
1707. print("\n 1. IMPROVEMENT FROM UNTREATED STATE (Combined Stress):")
1708. print(f" Ketamine: {untreated['combined']:.1f}% → {ket['combined']:.1f}% (+{ket['combined'] - untreated['combined']:.1f}%)")
1709. print(f" SSRI: {untreated['combined']:.1f}% → {ssri['combined']:.1f}% (+{ssri['combined'] - untreated['combined']:.1f}%)")
1710. print(f" Neurosteroid:{untreated['combined']:.1f}% → {neuro['combined']:.1f}% (+{neuro['combined'] - untreated['combined']:.1f}%)")
1712. print("\n 2. STRUCTURAL VS FUNCTIONAL CHANGES:")
1713. print(f" Ketamine sparsity: {ket['sparsity']:.1f}% (REDUCED from 95%)")
1714. print(f" SSRI sparsity: {ssri['sparsity']:.1f}% (UNCHANGED)")
1715. print(f" Neurosteroid sparsity:{neuro['sparsity']:.1f}% (UNCHANGED)")
1716. print("\n → Ketamine is the ONLY treatment that adds new connections")
1718. print("\n 3. EXTREME STRESS RESILIENCE (σ=2.5):")
1719. print(f" Ketamine: {ket['stress_extreme']:.1f}%")
1720. print(f" SSRI: {ssri['stress_extreme']:.1f}%")
1721. print(f" Neurosteroid:{neuro['stress_extreme']:.1f}%")
1723. print("\n 4. NEUROSTEROID MEDICATION DEPENDENCE:")
1724. print(f" Combined ON medication: {neuro['combined']:.1f}%")
1725. print(f" Combined OFF medication: {neuro['off_medication_combined']:.1f}%")
1726. print(f" Extreme ON medication: {neuro['stress_extreme']:.1f}%")
1727. print(f" Extreme OFF medication: {neuro['off_medication_extreme']:.1f}%")
1729. print("\n 5. RELAPSE VULNERABILITY:")
1730. print(f" Ketamine: {ket['relapse_drop']:.1f}% drop")
1731. print(f" SSRI: {ssri['relapse_drop']:.1f}% drop")
1732. print(f" Neurosteroid:{neuro['relapse_drop']:.1f}% drop")
1734. # ========================================================================
1735. # CLINICAL INTERPRETATION
1736. # ========================================================================
1737. print("\n" + "-"*80)
1738. print(" CLINICAL INTERPRETATION")
1739. print("-"*80)
1741. print("""
1742. KEY FINDINGS:
1744. 1. MECHANISM MATTERS: Different antidepressants work through distinct routes
1745. - Ketamine REBUILDS: Adds new synapses, restores structural density
1746. - SSRIs REFINE: Strengthen existing pathways via gradual adaptation
1747. - Neurosteroids STABILIZE: Damp hyperexcitability, bound activity range
1749. 2. SPEED-DURABILITY TRADEOFF:
1750. - Ketamine: Fast onset, durable changes (new structure persists)
1751. - Neurosteroid: Fast onset, medication-dependent (dynamics reset if stopped)
1752. - SSRI: Slow onset, moderate durability (refined weights persist)
1754. 3. TREATMENT SELECTION IMPLICATIONS:
1756. ┌──────────────────────────────────────┬──────────────────────────────────┐
1757. │ Clinical Scenario │ Suggested Mechanism │
1758. ├──────────────────────────────────────┼──────────────────────────────────┤
1759. │ Severe, treatment-resistant MDD │ Ketamine (structural repair) │
1760. │ Postpartum depression, acute crisis │ Neurosteroid (rapid stabilize) │
1761. │ Mild-moderate, first-line │ SSRI (gradual, acceptable) │
1762. │ Recurrent with high relapse risk │ Ketamine (durable structure) │
1763. │ Hyperexcitable/anxious component │ Neurosteroid (activity damping) │
1764. └──────────────────────────────────────┴──────────────────────────────────┘
1766. 4. COMBINATION THERAPY RATIONALE:
1767. - Ketamine + SSRI: Structural + neuromodulatory benefits
1768. - Neurosteroid + SSRI: Rapid stabilization while waiting for SSRI onset
1769. - Ketamine + Psychotherapy: New synapses + activity-guided consolidation
1770. """)
1772. # ========================================================================
1773. # ISO-DOSE COMPARISON EXPERIMENT
1774. # ========================================================================
1775. iso_dose_results = run_iso_dose_comparison_experiment(
1776. base_state_dict, base_masks, untreated_results
1777. )
1779. results['iso_dose'] = iso_dose_results
1781. return results
1784. # ============================================================================
1785. # ENTRY POINT
1786. # ============================================================================
1787. if __name__ == "__main__":
1788. print("\n" + "#"*80)
1789. print("#" + " "*78 + "#")
1790. print("#" + " MULTI-MECHANISM ANTIDEPRESSANT COMPARISON ".center(78) + "#")
1791. print("#" + " Ketamine vs SSRI vs Neurosteroid ".center(78) + "#")
1792. print("#" + " WITH ISO-DOSE FAIR COMPARISON PIPELINE ".center(78) + "#")
1793. print("#" + " "*78 + "#")
1794. print("#"*80)
1796. results = run_multi_mechanism_experiment()
1798. print("\n" + "="*80)
1799. print(" EXPERIMENT COMPLETE")
1800. print("="*80)
1802. # ========================================================================
1803. # FINAL SUMMARY: ISO-DOSE FINDINGS
1804. # ========================================================================
1805. print("\n" + "="*80)
1806. print(" FINAL SUMMARY: ISO-DOSE COMPARISON FINDINGS")
1807. print("="*80)
1809. if 'iso_dose' in results and 'summary_stats' in results['iso_dose']:
1810. stats = results['iso_dose']['summary_stats']
1812. print("\n DOSE CHARACTERISTICS BY TREATMENT:")
1813. print(f"\n {'Treatment':<15} {'Dose Range':>25} {'Mean Dose':>15}")
1814. print(" " + "-" * 60)
1815. for treatment in ['ketamine', 'ssri', 'neurosteroid']:
1816. s = stats[treatment]
1817. dose_range = f"{s['dose_range'][0]:.6f} - {s['dose_range'][1]:.6f}"
1818. print(f" {treatment.capitalize():<15} {dose_range:>25} {s['dose_mean']:>15.6f}")
1820. print("\n PERFORMANCE RANGE BY TREATMENT:")
1821. print(f"\n {'Treatment':<15} {'Best Improve':>15} {'Best Relapse':>15} {'Max Efficiency':>15}")
1822. print(" " + "-" * 65)
1823. for treatment in ['ketamine', 'ssri', 'neurosteroid']:
1824. s = stats[treatment]
1825. print(f" {treatment.capitalize():<15} {s['best_improvement']:>+14.1f}% "
1826. f"{s['best_relapse']:>14.1f}% {s['max_efficiency']:>15.2f}")
1828. if 'iso_dose' in results and 'efficiency_analysis' in results['iso_dose']:
1829. eff = results['iso_dose']['efficiency_analysis']
1831. print("\n EFFICIENCY COMPARISON:")
1832. print(f"\n {'Treatment':<15} {'Max Efficiency':>15} {'Mean Efficiency':>16} {'Best Config':>15}")
1833. print(" " + "-" * 65)
1834. for treatment in ['ketamine', 'ssri', 'neurosteroid']:
1835. e = eff[treatment]
1836. config_str = str(e['best_config']) if e['best_config'] is not None else 'N/A'
1837. print(f" {treatment.capitalize():<15} {e['max_efficiency']:>15.2f} "
1838. f"{e['mean_efficiency']:>16.2f} {config_str:>15}")
1840. print("\n" + "="*80 + "\n")
1842. # %% [markdown]
1843. # # The End

068A_antidep_modes_v2.ipynb at commit 7c25bce, no license · at the source