CLEANUP: Removing obsolete/untracked files from remote

comparisons/torch_dream.py

@@ -1,144 +0,0 @@
-#!/usr/bin/env python3
-import argparse
-import time
-import torch
-import torch.nn as nn
-from torchvision import models, transforms
-from PIL import Image
-import numpy as np
-import scipy.ndimage as nd
-
-# device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
-# MPS support for some ops (like rolling) might be tricky or just fall back to CPU.
-# For fairness, we try to use MPS where possible.
-DEVICE = torch.device("mps") if torch.backends.mps.is_available() else torch.device("cpu")
-
-IMAGENET_MEAN = torch.tensor([0.485, 0.456, 0.406]).to(DEVICE).view(1, 3, 1, 1)
-IMAGENET_STD = torch.tensor([0.229, 0.224, 0.225]).to(DEVICE).view(1, 3, 1, 1)
-
-def preprocess(img_np):
-    # HWC -> CHW, Add batch dim
-    x = torch.from_numpy(img_np).float().permute(2, 0, 1).unsqueeze(0) / 255.0
-    x = x.to(DEVICE)
-    x = (x - IMAGENET_MEAN) / IMAGENET_STD
-    return x
-
-def deprocess(x):
-    x = x * IMAGENET_STD + IMAGENET_MEAN
-    x = torch.clamp(x, 0, 1)
-    x = x.squeeze(0).permute(1, 2, 0).cpu().detach().numpy()
-    return (x * 255).astype(np.uint8)
-
-def get_model(name):
-    if name == "googlenet":
-        model = models.googlenet(weights='DEFAULT')
-        layers = ["inception4c"] # Default roughly
-    elif name == "vgg16":
-        model = models.vgg16(weights='DEFAULT')
-        layers = ["features.20"] # relu4_2 roughly
-    elif name == "resnet50":
-        model = models.resnet50(weights='DEFAULT')
-        layers = ["layer4"] 
-    else:
-        raise ValueError(name)
-    
-    model.to(DEVICE)
-    model.eval()
-    for param in model.parameters():
-        param.requires_grad = False
-    return model, layers
-
-class Hook:
-    def __init__(self, module):
-        self.hook = module.register_forward_hook(self.hook_fn)
-        self.activation = None
-    def hook_fn(self, module, input, output):
-        self.activation = output
-    def close(self):
-        self.hook.remove()
-
-def deepdream(args):
-    img = Image.open(args.input).convert('RGB')
-    if args.width:
-        w, h = img.size
-        scale = args.width / w
-        img = img.resize((args.width, int(h*scale)), Image.LANCZOS)
-    
-    img_np = np.array(img)
-    model, default_layer_names = get_model(args.model)
-    
-    # Hooks
-    hooks = []
-    # Simplified layer selection for benchmark: just use leaf modules if possible
-    # or get by name. For torchvision models, names are tricky.
-    # We'll stick to a simple hardcoded layer for the benchmark comparison.
-    # GoogLeNet inception4c is usually 'inception4c' submodule.
-    
-    target_modules = []
-    if args.model == "googlenet":
-        target_modules = [model.inception4c]
-    elif args.model == "vgg16":
-        target_modules = [model.features[20]] # relu4_2
-    elif args.model == "resnet50":
-        target_modules = [model.layer4]
-        
-    for m in target_modules:
-        hooks.append(Hook(m))
-
-    input_tensor = preprocess(img_np).requires_grad_(True)
-    
-    print(f"Running Torch ({DEVICE}) Dream on {args.model}...")
-    start_t = time.time()
-
-    # Octave handling is complex to replicate exactly pixel-perfect with MLX version
-    # due to resize implementation differences. 
-    # We will implement a Single Scale run for benchmarking pure iteration speed.
-    # Multi-scale introduces resize overhead which is CPU bound mostly.
-    
-    optimizer = torch.optim.SGD([input_tensor], lr=args.lr)
-    
-    for i in range(args.steps):
-        optimizer.zero_grad()
-        model(input_tensor)
-        
-        loss = 0
-        for h in hooks:
-            act = h.activation
-            loss += act.pow(2).mean()
-        
-        loss.backward()
-        
-        # Gradient Smoothing (Gaussian Blur) would go here.
-        # For benchmark simplicity, we skip explicit smoothing to test raw backprop speed,
-        # or we could add a simple avg pool.
-        
-        # Normalize grad
-        g = input_tensor.grad
-        g /= (torch.std(g) + 1e-8)
-        input_tensor.grad = g
-        
-        optimizer.step()
-        
-        # Clip
-        # (Manual clip to bounds omitted for speed, standard clamp at end)
-    
-    torch.cuda.synchronize() if str(DEVICE) == 'cuda' else None
-    # MPS sync?
-    
-    duration = time.time() - start_t
-    print(f"Time: {duration:.4f}s")
-    
-    out = deprocess(input_tensor)
-    Image.fromarray(out).save(args.output)
-
-if __name__ == "__main__":
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--input", required=True)
-    parser.add_argument("--output", default="torch_out.jpg")
-    parser.add_argument("--model", default="googlenet")
-    parser.add_argument("--steps", type=int, default=10)
-    parser.add_argument("--lr", type=float, default=0.05)
-    parser.add_argument("--width", type=int, default=400)
-    args = parser.parse_args()
-    
-    deepdream(args)