Backup more stuff.

Author: benedictchen

benchmark_new_features.py

@@ -0,0 +1,48 @@
+#!/usr/bin/env python3
+"""Check if learning rates are properly shared."""
+
+import sys
+import os
+import torch
+import torch.nn as nn
+
+# Add the src directory to Python path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from meta_learning.algorithms.meta_sgd import MetaSGD
+
+def check_lr_identity():
+    """Check if cloned model shares learning rate objects."""
+    print("🔍 Checking learning rate identity...")
+    
+    model = nn.Linear(2, 1)
+    meta_sgd = MetaSGD(model, lr=0.5)
+    
+    # Clone the model
+    cloned = meta_sgd.clone()
+    
+    # Check if learning rates are the same objects
+    for i, (orig_lr, cloned_lr) in enumerate(zip(meta_sgd.lrs, cloned.lrs)):
+        print(f"LR {i}: Same object? {orig_lr is cloned_lr}")
+        print(f"LR {i}: Values equal? {torch.allclose(orig_lr, cloned_lr)}")
+        print(f"LR {i}: Same ID? Original: {id(orig_lr)}, Cloned: {id(cloned_lr)}")
+    
+    # Try modifying original learning rates
+    with torch.no_grad():
+        meta_sgd.lrs[0].fill_(0.1)
+    
+    print(f"After modifying original:")
+    print(f"Original LR value: {meta_sgd.lrs[0].item()}")
+    print(f"Cloned LR value: {cloned.lrs[0].item()}")
+    
+    # Check if they are the same parameter list
+    print(f"ParameterList identity: {meta_sgd.lrs is cloned.lrs}")
+    
+    return meta_sgd.lrs is cloned.lrs
+
+if __name__ == "__main__":
+    same = check_lr_identity()
+    if same:
+        print("✅ Learning rates are properly shared")
+    else:
+        print("❌ Learning rates are NOT shared")

check_lr_identity.py

@@ -0,0 +1,128 @@
+#!/usr/bin/env python3
+"""Debug gradient flow in Meta-SGD."""
+
+import sys
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Add the src directory to Python path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from meta_learning.algorithms.meta_sgd import MetaSGD
+
+def debug_gradient_flow():
+    """Debug gradient flow step by step."""
+    print("🔍 Debugging gradient flow in Meta-SGD...")
+    
+    # Simple model
+    model = nn.Linear(2, 1)
+    meta_sgd = MetaSGD(model, lr=0.5, first_order=False)
+    
+    print(f"Learning rate requires grad: {meta_sgd.lrs[0].requires_grad}")
+    print(f"Learning rate grad_fn: {meta_sgd.lrs[0].grad_fn}")
+    
+    # Simple data
+    x = torch.tensor([[1.0, 1.0]], dtype=torch.float32)
+    y = torch.tensor([[0.5]], dtype=torch.float32)
+    
+    # Clone model for adaptation
+    task_model = meta_sgd.clone()
+    print(f"Cloned model LR requires grad: {task_model.lrs[0].requires_grad}")
+    print(f"Cloned model LR grad_fn: {task_model.lrs[0].grad_fn}")
+    
+    # Forward pass
+    pred = task_model(x)
+    print(f"Prediction: {pred}")
+    print(f"Prediction requires_grad: {pred.requires_grad}")
+    print(f"Prediction grad_fn: {pred.grad_fn}")
+    
+    # Compute loss
+    loss = F.mse_loss(pred, y)
+    print(f"Loss: {loss.item():.4f}")
+    print(f"Loss requires_grad: {loss.requires_grad}")
+    print(f"Loss grad_fn: {loss.grad_fn}")
+    
+    # Before adaptation - check if LR has gradients
+    if task_model.lrs[0].grad is not None:
+        print(f"LR grad before adaptation: {task_model.lrs[0].grad}")
+    else:
+        print("LR grad before adaptation: None")
+    
+    # Perform adaptation
+    print("\n--- Performing adaptation ---")
+    task_model.adapt(loss)
+    
+    # After adaptation - check model parameters
+    adapted_pred = task_model(x)
+    print(f"Adapted prediction: {adapted_pred}")
+    print(f"Adapted prediction requires_grad: {adapted_pred.requires_grad}")
+    print(f"Adapted prediction grad_fn: {adapted_pred.grad_fn}")
+    
+    # Meta loss
+    meta_loss = F.mse_loss(adapted_pred, y)
+    print(f"\nMeta-loss: {meta_loss.item():.4f}")
+    print(f"Meta-loss requires_grad: {meta_loss.requires_grad}")
+    print(f"Meta-loss grad_fn: {meta_loss.grad_fn}")
+    
+    # Check if learning rates are in computational graph
+    print("\n--- Checking computational graph ---")
+    if meta_loss.grad_fn is not None:
+        print("Meta-loss has grad_fn - computational graph exists")
+        
+        # Check if we can compute gradients w.r.t. learning rates
+        try:
+            lr_grad = torch.autograd.grad(meta_loss, task_model.lrs[0], retain_graph=True)
+            print(f"LR gradient computed: {lr_grad[0]}")
+            return True
+        except RuntimeError as e:
+            print(f"❌ Cannot compute LR gradient: {e}")
+            return False
+    else:
+        print("❌ Meta-loss has no grad_fn - no computational graph")
+        return False
+
+def debug_lr_connection():
+    """Debug if learning rates are connected to the forward pass."""
+    print("\n🔍 Debugging LR connection to forward pass...")
+    
+    model = nn.Linear(1, 1)
+    meta_sgd = MetaSGD(model, lr=1.0, first_order=False)
+    
+    # Manually check what happens in adaptation
+    x = torch.tensor([[1.0]])
+    y = torch.tensor([[0.0]])
+    
+    # Forward pass to get loss
+    pred = meta_sgd(x)
+    loss = F.mse_loss(pred, y)
+    
+    print(f"Initial loss: {loss.item():.4f}")
+    
+    # Get gradients manually  
+    grads = torch.autograd.grad(loss, meta_sgd.module.parameters(), create_graph=True)
+    print(f"Gradients computed: {[g.shape for g in grads]}")
+    
+    # Check if gradients have grad_fn (for second-order)
+    for i, g in enumerate(grads):
+        print(f"Gradient {i} grad_fn: {g.grad_fn}")
+    
+    # Manual update using learning rates
+    updated_params = []
+    for param, lr, grad in zip(meta_sgd.module.parameters(), meta_sgd.lrs, grads):
+        updated_param = param - lr * grad  # This should preserve gradients!
+        updated_params.append(updated_param)
+        print(f"Updated param grad_fn: {updated_param.grad_fn}")
+        print(f"LR grad_fn: {lr.grad_fn}")
+    
+    return True
+
+if __name__ == "__main__":
+    success1 = debug_gradient_flow()
+    success2 = debug_lr_connection()
+    
+    if success1 and success2:
+        print("\n✅ Gradient flow debugging complete")
+    else:
+        print("\n❌ Issues found in gradient flow")

debug_gradient_flow.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+"""Debug Meta-SGD learning rates."""
+
+import sys
+import os
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+# Add the src directory to Python path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from meta_learning.algorithms.meta_sgd import MetaSGD
+
+def debug_learning_rates():
+    """Debug why learning rates aren't updating."""
+    print("🔍 Debugging Meta-SGD learning rates...")
+    
+    # Create simple model
+    model = nn.Linear(3, 2)
+    meta_sgd = MetaSGD(model, lr=0.05)
+    
+    print(f"Number of learning rate parameters: {len(meta_sgd.lrs)}")
+    print(f"Learning rate requires_grad: {[lr.requires_grad for lr in meta_sgd.lrs]}")
+    
+    # Check if learning rates are in meta_sgd.parameters()
+    all_params = list(meta_sgd.parameters())
+    print(f"Total MetaSGD parameters: {len(all_params)}")
+    
+    # Separate module params from lr params
+    module_params = list(meta_sgd.module.parameters())
+    lr_params = list(meta_sgd.lrs)
+    
+    print(f"Module parameters: {len(module_params)}")
+    print(f"LR parameters: {len(lr_params)}")
+    
+    # Check if LR params are properly included
+    lr_param_ids = {id(p) for p in lr_params}
+    all_param_ids = {id(p) for p in all_params}
+    
+    lr_in_all = lr_param_ids.intersection(all_param_ids)
+    print(f"LR params in all params: {len(lr_in_all)}/{len(lr_param_ids)}")
+    
+    if len(lr_in_all) != len(lr_param_ids):
+        print("❌ Learning rate parameters are NOT included in meta_sgd.parameters()!")
+        print("This is why they're not being updated by the meta-optimizer")
+        return False
+    else:
+        print("✅ Learning rate parameters are properly included")
+        return True
+
+if __name__ == "__main__":
+    debug_learning_rates()

debug_meta_sgd_lrs.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+"""Debug Ridge regression gradient flow."""
+
+import sys
+import os
+import torch
+import torch.nn.functional as F
+
+# Add the src directory to Python path for testing
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), 'src'))
+
+from meta_learning.algorithms.metaoptnet import DifferentiableRidge
+
+def debug_ridge_gradients():
+    """Debug what's happening with Ridge gradients."""
+    print("🔍 Debugging Ridge regression gradients...")
+    
+    # Create Ridge solver
+    ridge = DifferentiableRidge(lam=1.0)
+    
+    # Create data with requires_grad
+    support_embeddings = torch.randn(10, 8, requires_grad=True)
+    support_labels = torch.randint(0, 3, (10,))
+    query_embeddings = torch.randn(5, 8, requires_grad=True)
+    
+    print(f"Support embeddings requires_grad: {support_embeddings.requires_grad}")
+    print(f"Query embeddings requires_grad: {query_embeddings.requires_grad}")
+    
+    # Forward pass
+    predictions = ridge(support_embeddings, support_labels, query_embeddings)
+    
+    print(f"Predictions requires_grad: {predictions.requires_grad}")
+    print(f"Predictions grad_fn: {predictions.grad_fn}")
+    
+    # Try to backpropagate
+    if predictions.requires_grad:
+        loss = predictions.sum()
+        loss.backward()
+        print(f"Support grad exists: {support_embeddings.grad is not None}")
+        print(f"Query grad exists: {query_embeddings.grad is not None}")
+    else:
+        print("❌ Cannot backpropagate - no grad_fn")
+    
+    return predictions.requires_grad
+
+if __name__ == "__main__":
+    success = debug_ridge_gradients()
+    if success:
+        print("✅ Ridge gradients working")
+    else:
+        print("❌ Ridge gradients broken")