Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,12 @@
+venv/
+__pycache__/
+*.DS_Store
+*.jpg
+*.png
+*.gif
+!assets/
+!input/
+*.jpg
+venv/
+pics/
+Agents.md

README.md

@@ -0,0 +1,168 @@
+---
+model_name: DeepDream-MLX
+model_description: Native, hardware-accelerated DeepDream for Apple Silicon.
+language: en
+library_name: mlx
+license: apache-2.0
+tags:
+- mlx
+- computer-vision
+- art
+- generative
+- deepdream
+pipeline_tag: image-to-image
+---
+# DeepDream-MLX
+
+<img src="assets/deepdream_header.jpg" alt="DeepDream Header" width="100%"/>
+
+**Status:** Fast. Native.
+**Vibe:** 2015 Hallucinations // 2025 Silicon.
+
+## ⚡️ Instant Gratification
+
+```bash
+# 1. Install Dependencies
+pip install mlx numpy pillow scipy
+
+# 2. Dream (VGG16 Default)
+python dream.py --input love.jpg
+
+# 3. Dream (All Models)
+python dream.py --input love.jpg --model all
+```
+
+## 🔮 The Lineage
+
+VGG and GoogLeNet: Cousins from the 2012 Big Bang. One went **Deep**, the other went **Wide**. We ported them all.
+
+```text
+╔═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╗
+║                                          THE CONVOLUTIONAL ANCESTRY                                                 ║
+╠═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╣
+║                                                                                                                     ║
+║          ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓                                                                               ║
+║          ┃      LeNet-5 (1998)      ┃  (The Grandfather)                                                            ║
+║          ┗━━━━━━━━━━━━┳━━━━━━━━━━━━━┛                                                                               ║
+║                       │                                                                                             ║
+║                       ▼                                                                                             ║
+║          ┏━━━━━━━━━━━━━━━━━━━━━━━━━━┓                                                                               ║
+║          ┃      AlexNet (2012)      ┃  (The Ignition)                                                               ║
+║          ┗━━━━━━━━━━━━┳━━━━━━━━━━━━━┛                                                                               ║
+║                       │                                                                                             ║
+║    ╔══════════════════╩════════════════════════════════════════════════════════════════════════════════╗            ║
+║    ║                                                                                                   ║            ║
+║    ▼                                              ▼                                                    ▼            ║
+║                                                                                                                     ║
+║ ╔══════════════════════════════════╗    ╔══════════════════════════════════╗    ╔═════════════════════════════════╗ ║
+║ ║        THE OXFORD BRANCH         ║    ║        THE GOOGLE BRANCH         ║    ║     THE RESIDUAL REVOLUTION     ║ ║
+║ ║      (Philosophy: "Deeper")      ║    ║      (Philosophy: "Wider")       ║    ║     (Philosophy: "Identity")    ║ ║
+║ ╚═════════════════╦════════════════╝    ╚═════════════════╦════════════════╝    ╚════════════════════╦════════════╝ ║
+║                   │                                       │                                          │              ║
+║         ┌─────────┴─────────┐                             │                                          │              ║
+║         │                   │                             │                                          │              ║
+║    ┏━━━━▼━━━━┓         ┏━━━━▼━━━━┓                   ┏━━━━▼━━━━┓                                ┏━━━━▼━━━━┓         ║
+║    ┃  VGG16  ┃         ┃  VGG19  ┃                   ┃Inception┃                                ┃ ResNet  ┃         ║
+║    ┃         ┃         ┃         ┃                   ┃   V1    ┃                                ┃   50    ┃         ║
+║    ┗━━━━┳━━━━┛         ┗━━━━┳━━━━┛                   ┗━━━━┳━━━━┛                                ┗━━━━┳━━━━┛         ║
+║         │                   │                             │                                          │              ║
+║    (The Painter)       (The Stylist)               (The Hallucinator)                             (The Modernist)   ║
+║         │                   │                             │                                          │              ║
+║         ▼                   ▼                             ▼                                          ▼              ║
+║   vgg16_mlx.npz       vgg19_mlx.npz               googlenet_mlx.npz                          resnet50_mlx.npz       ║
+║                                                                                                                     ║
+╚═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╝
+```
+
+## 🧠 The Models
+
+*   **VGG16:** General purpose image features.
+*   **GoogLeNet (InceptionV1):** The classic DeepDream model.
+*   **VGG19:** Deeper VGG features.
+*   **ResNet50:** Modern deep features.
+
+## 🧪 Recipes
+
+Copy-paste these to get the exact looks from the header.
+
+### 1. Classic Inception Patterns (GoogLeNet)
+*This setup targets various Inception layers for recognizable DeepDream shapes.*
+
+```bash
+python dream.py --input love.jpg \
+    --model googlenet \
+    --steps 22 \
+    --lr 0.061 \
+    --octaves 4 \
+    --scale 1.8 \
+    --jitter 26 \
+    --smoothing 0.08 \
+    --layers inception3a inception4e inception5b
+```
+
+### 2. Rich Textures (VGG16)
+*A VGG16 run for detailed, painterly results.*
+
+```bash
+python dream.py --input love.jpg \
+    --model vgg16 \
+    --steps 24 \
+    --lr 0.07 \
+    --octaves 4 \
+    --scale 1.8 \
+    --jitter 36 \
+    --smoothing 0.19 \
+    --layers relu4_2
+```
+
+### 3. Layered Patterns (VGG19)
+*A VGG19 run for complex, stylized outputs.*
+
+```bash
+python dream.py --input love.jpg \
+    --model vgg19 \
+    --steps 14 \
+    --lr 0.045 \
+    --octaves 2 \
+    --scale 1.5 \
+    --jitter 27 \
+    --smoothing 0.41 \
+    --layers relu5_2
+```
+
+### 4. Different VGG16 Vision
+*Another VGG16 setting, exploring alternative features.*
+
+```bash
+python dream.py --input love.jpg \
+    --model vgg16 \
+    --steps 24 \
+    --lr 0.069 \
+    --octaves 4 \
+    --scale 1.8 \
+    --jitter 10 \
+    --smoothing 0.41 \
+    --layers relu5_1
+```
+
+### 5. Sharp Abstract Forms (ResNet50)
+*Modern features from ResNet50 for distinct, edgy results.*
+
+```bash
+python dream.py --input love.jpg \
+    --model resnet50 \
+    --steps 22 \
+    --lr 0.13 \
+    --octaves 4 \
+    --scale 2 \
+    --jitter 83 \
+    --smoothing 0.47 \
+    --layers layer3_2 layer3_5
+```
+
+## 💾 Weight Conversion
+
+We took 10-year-old model weights from PyTorch/Torchvision (often based on original Caffe implementations) and converted them directly into optimized MLX `.npz` arrays. Our custom `export_*.py` scripts handle this. This brings these classic architectures to **Apple Silicon**, clean and efficient.
+
+---
+*NickMystic

config.json

@@ -0,0 +1,30 @@
+{
+  "_name_or_path": "DeepDream-MLX-Models",
+  "architectures": [
+    "GoogleNet",
+    "VGG16",
+    "VGG19"
+  ],
+  "model_type": "feature-extractor",
+  "framework": "mlx",
+  "task_specific_params": {
+    "deepdream": {
+      "description": "Models converted for DeepDream applications on Apple Silicon using MLX.",
+      "input_image_size": [224, 224],
+      "num_channels": 3,
+      "image_channel_order": "HWC",
+      "image_mean": [0.485, 0.456, 0.406],
+      "image_std": [0.229, 0.224, 0.225]
+    }
+  },
+  "license": "other",
+  "tags": [
+    "deepdream",
+    "mlx",
+    "computer-vision",
+    "googlenet",
+    "vgg16",
+    "vgg19",
+    "feature-extraction"
+  ]
+}

dream.py

@@ -0,0 +1,358 @@
+import argparse
+import os
+import time
+from datetime import datetime
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+import scipy.ndimage as nd
+from mlx_resnet50 import ResNet50
+from PIL import Image
+
+from mlx_googlenet import GoogLeNet
+from mlx_vgg16 import VGG16
+from mlx_vgg19 import VGG19
+
+IMAGENET_MEAN = mx.array([0.485, 0.456, 0.406])
+IMAGENET_STD = mx.array([0.229, 0.224, 0.225])
+LOWER_IMAGE_BOUND = (-IMAGENET_MEAN / IMAGENET_STD).reshape(1, 1, 1, 3)
+UPPER_IMAGE_BOUND = ((1.0 - IMAGENET_MEAN) / IMAGENET_STD).reshape(1, 1, 1, 3)
+
+
+def load_image(path, target_width=None):
+    img = Image.open(path).convert("RGB")
+    if target_width:
+        w, h = img.size
+        scale = target_width / w
+        new_h = int(h * scale)
+        img = img.resize((target_width, new_h), Image.LANCZOS)
+    return np.array(img)
+
+
+def preprocess(img_np):
+    x = mx.array(img_np, dtype=mx.float32) / 255.0
+    x = (x - IMAGENET_MEAN) / IMAGENET_STD
+    x = x[None, ...]  # NHWC
+    return x
+
+
+def deprocess(x):
+    x = x[0]
+    x = x * IMAGENET_STD + IMAGENET_MEAN
+    x = mx.clip(x, 0.0, 1.0)
+    x = (x * 255.0).astype(mx.uint8)
+    return np.array(x)
+
+
+def resize_bilinear(x, new_h, new_w):
+    b, h, w, c = x.shape
+    out = mx.zeros((b, new_h, new_w, c))
+    for bi in range(b):
+        for ci in range(c):
+            out[bi, :, :, ci] = mx.array(
+                nd.zoom(np.array(x[bi, :, :, ci]), zoom=(new_h / h, new_w / w), order=1)
+            )
+    return out
+
+
+def gaussian_kernel(sigma, truncate=4.0, fixed_radius=None):
+    """Generates a 1D Gaussian kernel."""
+    if fixed_radius is not None:
+        radius = fixed_radius
+    else:
+        radius = int(truncate * sigma + 0.5)
+        
+    x = mx.arange(-radius, radius + 1)
+    kernel = mx.exp(-0.5 * (x / sigma) ** 2)
+    kernel = kernel / kernel.sum()
+    return kernel
+
+
+def gaussian_blur_2d(x, sigma, fixed_radius=None):
+    """Applies Gaussian blur using separable 1D convolutions in MLX."""
+    kernel = gaussian_kernel(sigma, fixed_radius=fixed_radius)
+    kernel = kernel.astype(x.dtype)
+    k_size = kernel.shape[0]
+    C = x.shape[-1]
+    
+    k_x = kernel.reshape(1, 1, k_size, 1)
+    k_x = mx.repeat(k_x, C, axis=0)
+    k_y = kernel.reshape(1, k_size, 1, 1)
+    k_y = mx.repeat(k_y, C, axis=0)
+    
+    pad = k_size // 2
+    
+    x = mx.conv2d(x, k_x, stride=1, padding=(0, pad), groups=C)
+    x = mx.conv2d(x, k_y, stride=1, padding=(pad, 0), groups=C)
+    return x
+
+
+def smooth_gradients(grad, sigma, fixed_radius=None):
+    """Cascade 3 Gaussian blurs (sigma multipliers 0.5/1/2) using native MLX ops."""
+    sigmas = [sigma * 0.5, sigma * 1.0, sigma * 2.0]
+    smoothed = []
+    for s in sigmas:
+        smoothed.append(gaussian_blur_2d(grad, s, fixed_radius=fixed_radius))
+    
+    g_total = smoothed[0]
+    for i in range(1, len(smoothed)):
+        g_total = g_total + smoothed[i]
+    return g_total / len(smoothed)
+
+
+def get_pyramid_shapes(base_shape, num_octaves, scale):
+    h, w = base_shape
+    shapes = []
+    for level in range(num_octaves):
+        exponent = level - num_octaves + 1
+        nh = max(1, int(round(h * (scale**exponent))))
+        nw = max(1, int(round(w * (scale**exponent))))
+        shapes.append((nh, nw))
+    return shapes
+
+
+def deepdream(
+    model,
+    img_np,
+    layers,
+    steps,
+    lr,
+    num_octaves,
+    scale,
+    jitter=32,
+    smoothing=0.5,
+    guide_img_np=None,
+):
+    img = preprocess(img_np)
+    base_h, base_w = img.shape[1:3]
+    pyramid_shapes = get_pyramid_shapes((base_h, base_w), num_octaves, scale)
+
+    for level, (nh, nw) in enumerate(pyramid_shapes):
+        img = resize_bilinear(img, nh, nw)
+
+        guide_features = {}
+        if guide_img_np is not None:
+            guide_resized = resize_bilinear(preprocess(guide_img_np), nh, nw)
+            _, guide_features = model.forward_with_endpoints(guide_resized)
+        
+        def loss_fn(x):
+            endpoints = model.forward_with_endpoints(x)[1]
+            loss = mx.zeros(())
+            for name in layers:
+                act = endpoints[name]
+                if guide_img_np is not None:
+                    guide_act = guide_features[name]
+                    loss = loss + mx.mean(act * guide_act)
+                else:
+                    loss = loss + mx.mean(act * act)
+            return loss / len(layers)
+
+        # Calculate max radius needed for static compilation
+        max_effective_sigma = 2.0 * (2.0 + smoothing)
+        fixed_radius = int(4.0 * max_effective_sigma + 0.5)
+
+        @mx.compile
+        def update_step(x, sigma):
+            loss, grads = mx.value_and_grad(loss_fn)(x)
+            g = smooth_gradients(grads, sigma, fixed_radius=fixed_radius)
+            g = g - mx.mean(g)
+            g = g / (mx.std(g) + 1e-8)
+            x = x + lr * g
+            x = mx.minimum(mx.maximum(x, LOWER_IMAGE_BOUND), UPPER_IMAGE_BOUND)
+            return x, loss
+
+        for it in range(steps):
+            ox, oy = np.random.randint(-jitter, jitter + 1, 2)
+            rolled = mx.roll(mx.roll(img, ox, axis=1), oy, axis=2)
+            
+            sigma_val = ((it + 1) / steps) * 2.0 + smoothing
+            
+            rolled, loss = update_step(rolled, mx.array(sigma_val))
+            
+            img = mx.roll(mx.roll(rolled, -ox, axis=1), -oy, axis=2)
+            
+    return deprocess(img)
+
+
+def run_dream_for_model(model_name, args, img_np):
+    print(f"--- Running DeepDream with {model_name} ---")
+    
+    # Notebook presets
+    PRESETS = {
+        "nb14": {
+            "layers": ["relu3_3"],
+            "steps": 10,
+            "lr": 0.06,
+            "octaves": 6,
+            "scale": 1.4,
+            "jitter": 32,
+            "smoothing": 0.5,
+        },
+        "nb20": {
+            "layers": ["relu4_2"],
+            "steps": 10,
+            "lr": 0.06,
+            "octaves": 6,
+            "scale": 1.4,
+            "jitter": 32,
+            "smoothing": 0.5,
+        },
+        "nb28": {
+            "layers": ["relu5_3"],
+            "steps": 10,
+            "lr": 0.06,
+            "octaves": 6,
+            "scale": 1.4,
+            "jitter": 32,
+            "smoothing": 0.5,
+        },
+    }
+
+    # Defaults
+    current_layers = args.layers
+    current_steps = args.steps
+    current_lr = args.lr
+    current_octaves = args.octaves
+    current_scale = args.scale
+    current_jitter = args.jitter
+    current_smoothing = args.smoothing
+
+    # Model specific logic
+    if model_name == "vgg16":
+        model = VGG16()
+        weights = args.weights or "vgg16_mlx.npz"
+        default_layers = ["relu4_3"]
+        if args.preset:
+            p = PRESETS[args.preset]
+            # Apply preset overrides
+            current_layers = p["layers"]
+            current_steps = p["steps"]
+            current_lr = p["lr"]
+            current_octaves = p["octaves"]
+            current_scale = p["scale"]
+            current_jitter = p["jitter"]
+            current_smoothing = p["smoothing"]
+            
+    elif model_name == "vgg19":
+        model = VGG19()
+        weights = args.weights or "vgg19_mlx.npz"
+        default_layers = ["relu4_4"]
+        if args.preset and args.preset in PRESETS:
+            p = PRESETS[args.preset]
+            current_layers = p["layers"]
+            current_steps = p["steps"]
+            current_lr = p["lr"]
+            current_octaves = p["octaves"]
+            current_scale = p["scale"]
+            current_jitter = p["jitter"]
+            current_smoothing = p["smoothing"]
+            
+    elif model_name == "resnet50":
+        model = ResNet50()
+        weights = args.weights or "resnet50_mlx.npz"
+        default_layers = ["layer4_2"]
+        
+    else: # googlenet
+        model = GoogLeNet()
+        weights = args.weights or "googlenet_mlx.npz"
+        default_layers = ["inception3b", "inception4c", "inception4d"]
+
+    if not os.path.exists(weights):
+        print(f"Error: Weights NPZ not found: {weights}. Skipping {model_name}.")
+        return
+
+    model.load_npz(weights)
+
+    guide_img_np = None
+    if args.guide:
+        print(f"Using guide image: {args.guide}")
+        guide_img_np = load_image(args.guide, args.width)
+
+    start_time = time.time()
+    start_timestamp = datetime.now()
+
+    dreamed = deepdream(
+        model,
+        img_np,
+        layers=current_layers or default_layers,
+        steps=current_steps,
+        lr=current_lr,
+        num_octaves=current_octaves,
+        scale=current_scale,
+        jitter=current_jitter,
+        smoothing=current_smoothing,
+        guide_img_np=guide_img_np,
+    )
+    
+    end_time = time.time()
+    elapsed = end_time - start_time
+    
+    if args.output:
+        out = args.output
+    else:
+        base_name = os.path.splitext(os.path.basename(args.input))[0]
+        formatted_time = f"{elapsed:.2f}s"
+        formatted_date = start_timestamp.strftime("%m%d")
+        formatted_timestamp = start_timestamp.strftime("%H%M%S")
+        out = f"{base_name}_dream_{model_name}_{formatted_time}_{formatted_date}_{formatted_timestamp}.jpg"
+
+    Image.fromarray(dreamed).save(out)
+    print(f"Saved {out}\n")
+
+
+def parse_args():
+    p = argparse.ArgumentParser(description="DeepDream with MLX (Compiled)")
+    p.add_argument("--input", required=True, help="Input image path")
+    p.add_argument("--output", help="Output image path (optional)")
+    p.add_argument("--guide", help="Guide image for guided dreaming")
+    
+    p.add_argument("--width", type=int, default=None, help="Resize input to width (maintains aspect ratio)")
+    p.add_argument("--img_width", type=int, help="Alias for --width", dest="width") # Alias
+    
+    p.add_argument(
+        "--model",
+        choices=["vgg16", "vgg19", "googlenet", "resnet50", "all"],
+        default="vgg16",
+        help="Model to use. 'all' runs all models.",
+    )
+    p.add_argument("--preset", choices=["nb14", "nb20", "nb28"], help="VGG16 presets")
+    
+    p.add_argument("--layers", nargs="+", help="Layers to maximize")
+    p.add_argument("--steps", type=int, default=10, help="Gradient ascent steps per octave")
+    p.add_argument("--lr", type=float, default=0.09, help="Learning rate (step size)")
+    
+    p.add_argument("--octaves", type=int, default=4, help="Number of image octaves")
+    p.add_argument("--pyramid_size", type=int, dest="octaves", help="Alias for --octaves") # Alias
+    
+    p.add_argument("--scale", type=float, default=1.8, help="Octave scale factor")
+    p.add_argument("--pyramid_ratio", type=float, dest="scale", help="Alias for --scale") # Alias
+    p.add_argument("--octave_scale", type=float, dest="scale", help="Alias for --scale") # Alias
+    
+    p.add_argument("--jitter", type=int, default=32, help="Jitter amount (pixels)")
+    
+    p.add_argument("--smoothing", type=float, default=0.5, help="Gradient smoothing strength")
+    p.add_argument("--smoothing_coefficient", type=float, dest="smoothing", help="Alias for --smoothing") # Alias
+    
+    p.add_argument("--weights", help="Custom weights path")
+    
+    return p.parse_args()
+
+
+def main():
+    args = parse_args()
+    img_np = load_image(args.input, args.width)
+
+    if args.model == 'all':
+        models = ["vgg16", "vgg19", "googlenet", "resnet50"]
+        if args.output:
+            print("Warning: --output argument ignored because --model='all' was selected.")
+            args.output = None 
+        for m in models:
+            run_dream_for_model(m, args, img_np)
+    else:
+        run_dream_for_model(args.model, args, img_np)
+
+
+if __name__ == "__main__":
+    main()

export_googlenet_npz.py

@@ -0,0 +1,21 @@
+"""
+Export torchvision GoogLeNet (Inception V1) weights to an .npz for MLX.
+Run this in a PyTorch+torchvision env:
+    python export_googlenet_npz.py
+It writes models/googlenet_mlx.npz
+"""
+import os
+import numpy as np
+import torch
+from torchvision.models import googlenet, GoogLeNet_Weights
+
+def main():
+    model = googlenet(weights=GoogLeNet_Weights.IMAGENET1K_V1)
+    state = model.state_dict()
+    os.makedirs("models", exist_ok=True)
+    out_path = os.path.join("models", "googlenet_mlx.npz")
+    np.savez(out_path, **{k: v.cpu().numpy() for k, v in state.items()})
+    print(f"Saved {out_path} with {len(state)} tensors.")
+
+if __name__ == "__main__":
+    main()

export_resnet50_npz.py

@@ -0,0 +1,23 @@
+"""
+Export torchvision ResNet50 weights to an .npz for MLX.
+Run this in a PyTorch+torchvision env:
+    python export_resnet50_npz.py
+It writes models/resnet50_mlx.npz
+"""
+import os
+import numpy as np
+import torch
+from torchvision.models import resnet50, ResNet50_Weights
+
+
+def main():
+    model = resnet50(weights=ResNet50_Weights.IMAGENET1K_V1)
+    state = model.state_dict()
+    os.makedirs("models", exist_ok=True)
+    out_path = os.path.join("models", "resnet50_mlx.npz")
+    np.savez(out_path, **{k: v.cpu().numpy() for k, v in state.items()})
+    print(f"Saved {out_path} with {len(state)} tensors.")
+
+
+if __name__ == "__main__":
+    main()

export_vgg16_npz.py

@@ -0,0 +1,23 @@
+"""
+Export torchvision VGG16 weights to an .npz for MLX.
+Run this in a PyTorch+torchvision env:
+    python export_vgg16_npz.py
+It writes models/vgg16_mlx.npz
+"""
+import os
+import numpy as np
+import torch
+from torchvision.models import vgg16, VGG16_Weights
+
+
+def main():
+    model = vgg16(weights=VGG16_Weights.IMAGENET1K_V1)
+    state = model.state_dict()
+    os.makedirs("models", exist_ok=True)
+    out_path = os.path.join("models", "vgg16_mlx.npz")
+    np.savez(out_path, **{k: v.cpu().numpy() for k, v in state.items()})
+    print(f"Saved {out_path} with {len(state)} tensors.")
+
+
+if __name__ == "__main__":
+    main()

export_vgg19_npz.py

@@ -0,0 +1,23 @@
+"""
+Export torchvision VGG19 weights to an .npz for MLX.
+Run this in a PyTorch+torchvision env:
+    python export_vgg19_npz.py
+It writes models/vgg19_mlx.npz
+"""
+import os
+import numpy as np
+import torch
+from torchvision.models import vgg19, VGG19_Weights
+
+
+def main():
+    model = vgg19(weights=VGG19_Weights.IMAGENET1K_V1)
+    state = model.state_dict()
+    os.makedirs("models", exist_ok=True)
+    out_path = os.path.join("models", "vgg19_mlx.npz")
+    np.savez(out_path, **{k: v.cpu().numpy() for k, v in state.items()})
+    print(f"Saved {out_path} with {len(state)} tensors.")
+
+
+if __name__ == "__main__":
+    main()

googlenet_mlx.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:835f92d1b0cf9c4f2977b59603f03f0e96ffb9e055a668e77b45aea166e14c14
+size 26661322

inference.py

@@ -0,0 +1,76 @@
+import mlx.core as mx
+import numpy as np
+from PIL import Image
+from mlx_googlenet import GoogLeNet
+# from mlx_vgg16 import VGG16 # Uncomment to use VGG16
+# from mlx_vgg19 import VGG19 # Uncomment to use VGG19
+
+def preprocess_image(image_path: str, target_size=(224, 224)):
+    """
+    Loads and preprocesses an image for MLX models.
+    Resizes, normalizes, and converts to HWC MLX array.
+    """
+    mean = np.array([0.485, 0.456, 0.406])
+    std = np.array([0.229, 0.224, 0.225])
+
+    image = Image.open(image_path).convert("RGB")
+    image = image.resize(target_size)
+    image = np.array(image, dtype=np.float32) / 255.0 # Scale to [0, 1]
+
+    # Normalize
+    image = (image - mean) / std
+
+    # Add batch dimension (B, H, W, C) and convert to MLX array
+    image = mx.array(image[np.newaxis, ...])
+    return image
+
+def main():
+    # Path to a dummy input image. You might need to create one or use an existing one.
+    # For example, you can create a dummy 224x224 black image with:
+    # `convert -size 224x224 xc:black dummy_input.png` (if ImageMagick is installed)
+    # Or simply have an image named 'dummy_input.png' in the same directory.
+    input_image_path = "dummy_input.png"
+
+    # --- Load and preprocess image ---
+    try:
+        input_image = preprocess_image(input_image_path)
+        print(f"Preprocessed image shape: {input_image.shape}")
+    except FileNotFoundError:
+        print(f"Error: Input image '{input_image_path}' not found.")
+        print("Please create a dummy_input.png or replace the path with an existing image.")
+        return
+
+    # --- Load GoogleNet model and weights ---
+    print("Loading GoogleNet model...")
+    model = GoogLeNet()
+    try:
+        model.load_npz("googlenet_mlx.npz")
+        print("GoogleNet weights loaded successfully.")
+    except FileNotFoundError:
+        print("Error: googlenet_mlx.npz not found.")
+        print("Ensure 'googlenet_mlx.npz' is in the same directory as this script.")
+        return
+
+    # --- Perform inference ---
+    print("Performing inference...")
+    # The GoogleNet model returns a dictionary of activations for DeepDream
+    activations = model(input_image)
+    print("Inference complete.")
+
+    # --- Display some output ---
+    print("\nGoogleNet Activations (Layer Names and Shapes):")
+    for layer_name, output_tensor in activations.items():
+        print(f"  {layer_name}: {output_tensor.shape}")
+
+    # You can uncomment and use VGG16/VGG19 similarly:
+    # print("\n--- VGG16 Example (uncomment to run) ---")
+    # vgg_model = VGG16()
+    # vgg_model.load_npz("vgg16_mlx.npz")
+    # vgg_activations = vgg_model(input_image)
+    # print("VGG16 Activations (Layer Names and Shapes):")
+    # for layer_name, output_tensor in vgg_activations.items():
+    #     print(f"  {layer_name}: {output_tensor.shape}")
+
+
+if __name__ == "__main__":
+    main()

mlx_googlenet.py

@@ -0,0 +1,147 @@
+"""
+Minimal GoogLeNet (Inception V1) in MLX, up to inception4e.
+Loads weights from a torchvision-exported npz (see export_googlenet_npz.py).
+"""
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+
+
+def _conv_bn(in_ch, out_ch, kernel_size, stride=1, padding=0):
+    return nn.Sequential(
+        nn.Conv2d(
+            in_ch,
+            out_ch,
+            kernel_size=kernel_size,
+            stride=stride,
+            padding=padding,
+            bias=False,
+        ),
+        nn.BatchNorm(out_ch, eps=1e-3, momentum=0.1),
+        nn.ReLU(),
+    )
+
+
+class Inception(nn.Module):
+    def __init__(self, in_ch, ch1, ch3r, ch3, ch5r, ch5, pool_proj):
+        super().__init__()
+        self.branch1 = _conv_bn(in_ch, ch1, 1)
+
+        self.branch2_1 = _conv_bn(in_ch, ch3r, 1)
+        self.branch2_2 = _conv_bn(ch3r, ch3, 3, padding=1)
+
+        self.branch3_1 = _conv_bn(in_ch, ch5r, 1)
+        # The reference torchvision GoogLeNet uses a 3x3 conv here (not 5x5)
+        self.branch3_2 = _conv_bn(ch5r, ch5, 3, padding=1)
+
+        self.branch4_pool = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)
+        self.branch4_2 = _conv_bn(in_ch, pool_proj, 1)
+
+    def __call__(self, x):
+        b1 = self.branch1(x)
+        b2 = self.branch2_2(self.branch2_1(x))
+        b3 = self.branch3_2(self.branch3_1(x))
+        b4 = self.branch4_2(self.branch4_pool(x))
+        return mx.concatenate([b1, b2, b3, b4], axis=-1)
+
+
+class GoogLeNet(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.conv1 = _conv_bn(3, 64, 7, stride=2, padding=3)
+        self.maxpool1 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
+
+        self.conv2 = _conv_bn(64, 64, 1)
+        self.conv3 = _conv_bn(64, 192, 3, padding=1)
+        self.maxpool2 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
+
+        self.inception3a = Inception(192, 64, 96, 128, 16, 32, 32)
+        self.inception3b = Inception(256, 128, 128, 192, 32, 96, 64)
+        self.maxpool3 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0)
+
+        self.inception4a = Inception(480, 192, 96, 208, 16, 48, 64)
+        self.inception4b = Inception(512, 160, 112, 224, 24, 64, 64)
+        self.inception4c = Inception(512, 128, 128, 256, 24, 64, 64)
+        self.inception4d = Inception(512, 112, 144, 288, 32, 64, 64)
+        self.inception4e = Inception(528, 256, 160, 320, 32, 128, 128)
+        self.maxpool4 = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+        self.inception5a = Inception(832, 256, 160, 320, 32, 128, 128)
+        self.inception5b = Inception(832, 384, 192, 384, 48, 128, 128)
+
+    def forward_with_endpoints(self, x):
+        endpoints = {}
+        x = self.conv1(x)
+        x = self.maxpool1(x)
+
+        x = self.conv2(x)
+        x = self.conv3(x)
+        x = self.maxpool2(x)
+
+        x = self.inception3a(x)
+        endpoints["inception3a"] = x
+        x = self.inception3b(x)
+        endpoints["inception3b"] = x
+        x = self.maxpool3(x)
+
+        x = self.inception4a(x)
+        endpoints["inception4a"] = x
+        x = self.inception4b(x)
+        endpoints["inception4b"] = x
+        x = self.inception4c(x)
+        endpoints["inception4c"] = x
+        x = self.inception4d(x)
+        endpoints["inception4d"] = x
+        x = self.inception4e(x)
+        endpoints["inception4e"] = x
+        x = self.maxpool4(x)
+
+        x = self.inception5a(x)
+        endpoints["inception5a"] = x
+        x = self.inception5b(x)
+        endpoints["inception5b"] = x
+        return x, endpoints
+
+    def __call__(self, x):
+        _, endpoints = self.forward_with_endpoints(x)
+        return endpoints
+
+    def load_npz(self, path: str):
+        data = np.load(path)
+
+        def to_mlx_weight(w):
+            # PyTorch Conv2d weights are (out_channels, in_channels, kH, kW)
+            # MLX expects channel-last filters: (out_channels, kH, kW, in_channels)
+            return np.transpose(w, (0, 2, 3, 1)) if w.ndim == 4 else w
+
+        def load_conv_bn(prefix, seq_mod: nn.Sequential):
+            conv = seq_mod.layers[0]
+            bn = seq_mod.layers[1]
+            conv.weight = mx.array(to_mlx_weight(data[f"{prefix}.conv.weight"]))
+            bn.weight = mx.array(data[f"{prefix}.bn.weight"])
+            bn.bias = mx.array(data[f"{prefix}.bn.bias"])
+            bn.running_mean = mx.array(data[f"{prefix}.bn.running_mean"])
+            bn.running_var = mx.array(data[f"{prefix}.bn.running_var"])
+
+        load_conv_bn("conv1", self.conv1)
+        load_conv_bn("conv2", self.conv2)
+        load_conv_bn("conv3", self.conv3)
+
+        def load_inception(prefix, module: Inception):
+            load_conv_bn(f"{prefix}.branch1", module.branch1)
+            load_conv_bn(f"{prefix}.branch2.0", module.branch2_1)
+            load_conv_bn(f"{prefix}.branch2.1", module.branch2_2)
+            load_conv_bn(f"{prefix}.branch3.0", module.branch3_1)
+            load_conv_bn(f"{prefix}.branch3.1", module.branch3_2)
+            load_conv_bn(f"{prefix}.branch4.1", module.branch4_2)
+
+        load_inception("inception3a", self.inception3a)
+        load_inception("inception3b", self.inception3b)
+        load_inception("inception4a", self.inception4a)
+        load_inception("inception4b", self.inception4b)
+        load_inception("inception4c", self.inception4c)
+        load_inception("inception4d", self.inception4d)
+        load_inception("inception4e", self.inception4e)
+        load_inception("inception5a", self.inception5a)
+        load_inception("inception5b", self.inception5b)

mlx_resnet50.py

@@ -0,0 +1,153 @@
+"""
+ResNet50 in MLX for DeepDream.
+Loads weights from a torchvision-exported npz (see export_resnet50_npz.py).
+"""
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+
+class Bottleneck(nn.Module):
+    expansion = 4
+
+    def __init__(self, inplanes, planes, stride=1, downsample=None):
+        super().__init__()
+        self.conv1 = nn.Conv2d(inplanes, planes, kernel_size=1, bias=False)
+        self.bn1 = nn.BatchNorm(planes, eps=1e-5, momentum=0.1)
+        self.conv2 = nn.Conv2d(planes, planes, kernel_size=3, stride=stride, padding=1, bias=False)
+        self.bn2 = nn.BatchNorm(planes, eps=1e-5, momentum=0.1)
+        self.conv3 = nn.Conv2d(planes, planes * self.expansion, kernel_size=1, bias=False)
+        self.bn3 = nn.BatchNorm(planes * self.expansion, eps=1e-5, momentum=0.1)
+        self.relu = nn.ReLU()
+        self.downsample = downsample
+
+    def __call__(self, x):
+        identity = x
+
+        out = self.conv1(x)
+        out = self.bn1(out)
+        out = self.relu(out)
+
+        out = self.conv2(out)
+        out = self.bn2(out)
+        out = self.relu(out)
+
+        out = self.conv3(out)
+        out = self.bn3(out)
+
+        if self.downsample is not None:
+            identity = self.downsample(x)
+
+        out = out + identity
+        out = self.relu(out)
+
+        return out
+
+class ResNet(nn.Module):
+    def __init__(self, block, layers):
+        super().__init__()
+        self.inplanes = 64
+        
+        # Initial layers
+        self.conv1 = nn.Conv2d(3, self.inplanes, kernel_size=7, stride=2, padding=3, bias=False)
+        self.bn1 = nn.BatchNorm(self.inplanes, eps=1e-5, momentum=0.1)
+        self.relu = nn.ReLU()
+        self.maxpool = nn.MaxPool2d(kernel_size=3, stride=2, padding=1)
+
+        self.layer1 = self._make_layer(block, 64, layers[0])
+        self.layer2 = self._make_layer(block, 128, layers[1], stride=2)
+        self.layer3 = self._make_layer(block, 256, layers[2], stride=2)
+        self.layer4 = self._make_layer(block, 512, layers[3], stride=2)
+
+    def _make_layer(self, block, planes, blocks, stride=1):
+        downsample = None
+        if stride != 1 or self.inplanes != planes * block.expansion:
+            downsample = nn.Sequential(
+                nn.Conv2d(self.inplanes, planes * block.expansion, kernel_size=1, stride=stride, bias=False),
+                nn.BatchNorm(planes * block.expansion, eps=1e-5, momentum=0.1),
+            )
+
+        layers = []
+        layers.append(block(self.inplanes, planes, stride, downsample))
+        self.inplanes = planes * block.expansion
+        for _ in range(1, blocks):
+            layers.append(block(self.inplanes, planes))
+
+        return nn.Sequential(*layers)
+
+    def forward_with_endpoints(self, x):
+        endpoints = {}
+        
+        x = self.conv1(x)
+        x = self.bn1(x)
+        x = self.relu(x)
+        endpoints['conv1'] = x
+        
+        x = self.maxpool(x)
+        
+        # Layer 1
+        for i, layer in enumerate(self.layer1.layers):
+            x = layer(x)
+            endpoints[f'layer1_{i}'] = x
+        endpoints['layer1'] = x
+
+        # Layer 2
+        for i, layer in enumerate(self.layer2.layers):
+            x = layer(x)
+            endpoints[f'layer2_{i}'] = x
+        endpoints['layer2'] = x
+
+        # Layer 3
+        for i, layer in enumerate(self.layer3.layers):
+            x = layer(x)
+            endpoints[f'layer3_{i}'] = x
+        endpoints['layer3'] = x
+
+        # Layer 4
+        for i, layer in enumerate(self.layer4.layers):
+            x = layer(x)
+            endpoints[f'layer4_{i}'] = x
+        endpoints['layer4'] = x
+
+        return x, endpoints
+
+    def load_npz(self, path: str):
+        data = np.load(path)
+
+        def to_mlx_weight(w):
+            return np.transpose(w, (0, 2, 3, 1)) if w.ndim == 4 else w
+
+        def load_bn(prefix, bn):
+            bn.weight = mx.array(data[f"{prefix}.weight"])
+            bn.bias = mx.array(data[f"{prefix}.bias"])
+            bn.running_mean = mx.array(data[f"{prefix}.running_mean"])
+            bn.running_var = mx.array(data[f"{prefix}.running_var"])
+
+        def load_conv(prefix, conv):
+            conv.weight = mx.array(to_mlx_weight(data[f"{prefix}.weight"]))
+        
+        # Initial layers
+        load_conv("conv1", self.conv1)
+        load_bn("bn1", self.bn1)
+
+        def load_layer(prefix, layer_mod):
+            for i, block in enumerate(layer_mod.layers):
+                block_prefix = f"{prefix}.{i}"
+                load_conv(f"{block_prefix}.conv1", block.conv1)
+                load_bn(f"{block_prefix}.bn1", block.bn1)
+                load_conv(f"{block_prefix}.conv2", block.conv2)
+                load_bn(f"{block_prefix}.bn2", block.bn2)
+                load_conv(f"{block_prefix}.conv3", block.conv3)
+                load_bn(f"{block_prefix}.bn3", block.bn3)
+                
+                if block.downsample is not None:
+                    load_conv(f"{block_prefix}.downsample.0", block.downsample.layers[0])
+                    load_bn(f"{block_prefix}.downsample.1", block.downsample.layers[1])
+
+        load_layer("layer1", self.layer1)
+        load_layer("layer2", self.layer2)
+        load_layer("layer3", self.layer3)
+        load_layer("layer4", self.layer4)
+
+def ResNet50():
+    return ResNet(Bottleneck, [3, 4, 6, 3])

mlx_vgg16.py

@@ -0,0 +1,91 @@
+"""
+VGG16 in MLX with endpoints for relu1_2, relu2_2, relu3_3, relu4_2, relu4_3,
+relu5_2, relu5_3. Loads weights from a torchvision-exported npz
+(see export_vgg16_npz.py).
+"""
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+
+
+def _conv(in_ch, out_ch, kernel_size=3, padding=1):
+    return nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, padding=padding, bias=True)
+
+
+class VGG16(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.layers = [
+            _conv(3, 64),  # 0 conv1_1
+            nn.ReLU(),
+            _conv(64, 64),  # 2 conv1_2
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            _conv(64, 128),  # 5 conv2_1
+            nn.ReLU(),
+            _conv(128, 128),  # 7 conv2_2
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            _conv(128, 256),  # 10 conv3_1
+            nn.ReLU(),
+            _conv(256, 256),  # 12 conv3_2
+            nn.ReLU(),
+            _conv(256, 256),  # 14 conv3_3
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            _conv(256, 512),  # 17 conv4_1
+            nn.ReLU(),
+            _conv(512, 512),  # 19 conv4_2
+            nn.ReLU(),
+            _conv(512, 512),  # 21 conv4_3
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+            _conv(512, 512),  # 24 conv5_1
+            nn.ReLU(),
+            _conv(512, 512),  # 26 conv5_2
+            nn.ReLU(),
+            _conv(512, 512),  # 28 conv5_3
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        ]
+
+        # Layer indices in self.layers corresponding to named endpoints
+        self.endpoint_indices = {
+            "relu1_2": 3,
+            "relu2_2": 8,
+            "relu3_3": 15,
+            "relu4_1": 18,
+            "relu4_2": 20,
+            "relu4_3": 22,
+            "relu5_1": 25,
+            "relu5_2": 27,
+            "relu5_3": 29,
+        }
+
+    def forward_with_endpoints(self, x):
+        endpoints = {}
+        for idx, layer in enumerate(self.layers):
+            x = layer(x)
+            for name, i in self.endpoint_indices.items():
+                if idx == i:
+                    endpoints[name] = x
+        return x, endpoints
+
+    def __call__(self, x):
+        _, endpoints = self.forward_with_endpoints(x)
+        return endpoints
+
+    def load_npz(self, path: str):
+        data = np.load(path)
+
+        def to_mlx_weight(w):
+            return np.transpose(w, (0, 2, 3, 1)) if w.ndim == 4 else w
+
+        conv_indices = [0, 2, 5, 7, 10, 12, 14, 17, 19, 21, 24, 26, 28]
+        for idx in conv_indices:
+            conv = self.layers[idx]
+            weight_key = f"features.{idx}.weight"
+            bias_key = f"features.{idx}.bias"
+            conv.weight = mx.array(to_mlx_weight(data[weight_key]))
+            conv.bias = mx.array(data[bias_key])

mlx_vgg19.py

@@ -0,0 +1,104 @@
+"""
+VGG19 in MLX with endpoints for common DeepDream layers.
+Loads weights from a torchvision-exported npz (see export_vgg19_npz.py).
+"""
+
+import mlx.core as mx
+import mlx.nn as nn
+import numpy as np
+
+
+def _conv(in_ch, out_ch, kernel_size=3, padding=1):
+    return nn.Conv2d(in_ch, out_ch, kernel_size=kernel_size, padding=padding, bias=True)
+
+
+class VGG19(nn.Module):
+    def __init__(self):
+        super().__init__()
+        # Mirrors torchvision.models.vgg19(features) layout
+        self.layers = [
+            _conv(3, 64),  # 0 conv1_1
+            nn.ReLU(),
+            _conv(64, 64),  # 2 conv1_2
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            _conv(64, 128),  # 5 conv2_1
+            nn.ReLU(),
+            _conv(128, 128),  # 7 conv2_2
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            _conv(128, 256),  # 10 conv3_1
+            nn.ReLU(),
+            _conv(256, 256),  # 12 conv3_2
+            nn.ReLU(),
+            _conv(256, 256),  # 14 conv3_3
+            nn.ReLU(),
+            _conv(256, 256),  # 16 conv3_4
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            _conv(256, 512),  # 19 conv4_1
+            nn.ReLU(),
+            _conv(512, 512),  # 21 conv4_2
+            nn.ReLU(),
+            _conv(512, 512),  # 23 conv4_3
+            nn.ReLU(),
+            _conv(512, 512),  # 25 conv4_4
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+
+            _conv(512, 512),  # 28 conv5_1
+            nn.ReLU(),
+            _conv(512, 512),  # 30 conv5_2
+            nn.ReLU(),
+            _conv(512, 512),  # 32 conv5_3
+            nn.ReLU(),
+            _conv(512, 512),  # 34 conv5_4
+            nn.ReLU(),
+            nn.MaxPool2d(kernel_size=2, stride=2),
+        ]
+
+        self.endpoint_indices = {
+            "relu1_2": 3,
+            "relu2_2": 8,
+            "relu3_2": 13,
+            "relu3_3": 15,
+            "relu3_4": 17,
+            "relu4_1": 20,
+            "relu4_2": 22,
+            "relu4_3": 24,
+            "relu4_4": 26,
+            "relu5_1": 29,
+            "relu5_2": 31,
+            "relu5_3": 33,
+            "relu5_4": 35,
+        }
+
+    def forward_with_endpoints(self, x):
+        endpoints = {}
+        for idx, layer in enumerate(self.layers):
+            x = layer(x)
+            for name, i in self.endpoint_indices.items():
+                if idx == i:
+                    endpoints[name] = x
+        return x, endpoints
+
+    def __call__(self, x):
+        _, endpoints = self.forward_with_endpoints(x)
+        return endpoints
+
+    def load_npz(self, path: str):
+        data = np.load(path)
+
+        def to_mlx_weight(w):
+            return np.transpose(w, (0, 2, 3, 1)) if w.ndim == 4 else w
+
+        conv_indices = [0, 2, 5, 7, 10, 12, 14, 16, 19, 21, 23, 25, 28, 30, 32, 34]
+        for idx in conv_indices:
+            conv = self.layers[idx]
+            weight_key = f"features.{idx}.weight"
+            bias_key = f"features.{idx}.bias"
+            conv.weight = mx.array(to_mlx_weight(data[weight_key]))
+            conv.bias = mx.array(data[bias_key])

requirements.txt

@@ -0,0 +1,4 @@
+mlx
+numpy
+Pillow
+scipy

resnet50_mlx.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d25d75e904c01e308ef81b57ab48756056d7154b0360a700deb3c22ad9207188
+size 102530262

tf_inception_v1.py

@@ -0,0 +1,79 @@
+"""TF-Slim InceptionV1 forward callable for TF2 (no KerasTensor issues)."""
+
+import os
+from typing import Iterable, Tuple, Callable, List
+
+import tensorflow as tf
+import tf_slim as slim
+from tf_slim.nets import inception_v1
+
+WEIGHTS_URL = "http://download.tensorflow.org/models/inception_v1_2016_08_28.tar.gz"
+DEFAULT_LAYER_NAMES = (
+    "Mixed_4b",
+    "Mixed_4c",
+    "Mixed_4d",
+)
+
+
+def _download_checkpoint_if_needed(weights_path: str = None) -> str:
+    if weights_path:
+        if not os.path.exists(weights_path):
+            raise FileNotFoundError(f"Weights path does not exist: {weights_path}")
+        return weights_path
+
+    tar_path = tf.keras.utils.get_file(
+        origin=WEIGHTS_URL,
+        fname=os.path.basename(WEIGHTS_URL),
+        extract=True,
+        cache_dir=os.path.expanduser("~/.keras"),
+    )
+    ckpt_dir = os.path.join(os.path.dirname(tar_path), "inception_v1_2016_08_28")
+    ckpt_path = os.path.join(ckpt_dir, "inception_v1.ckpt")
+    if not os.path.exists(ckpt_path):
+        raise FileNotFoundError(f"Checkpoint not found after download: {ckpt_path}")
+    return ckpt_path
+
+
+def _preprocess_fn(x: tf.Tensor) -> tf.Tensor:
+    """Match TF-Slim InceptionV1 preprocessing: scale to [-1, 1]."""
+    x = tf.cast(x, tf.float32)
+    return (x / 127.5) - 1.0
+
+
+def build_inception_v1_callable(
+    layer_names: Iterable[str] = DEFAULT_LAYER_NAMES, weights_path: str = None
+) -> Tuple[Callable[[tf.Tensor], List[tf.Tensor]], Callable[[tf.Tensor], tf.Tensor]]:
+    """
+    Returns:
+        forward_fn: callable taking NHWC float tensor -> list of endpoints
+        preprocess_fn: preprocessing callable
+    """
+
+    layer_names = tuple(layer_names)
+    scope_name = "InceptionV1"
+
+    @tf.function
+    def forward_fn(x: tf.Tensor) -> List[tf.Tensor]:
+        with tf.compat.v1.variable_scope(scope_name, reuse=tf.compat.v1.AUTO_REUSE):
+            with slim.arg_scope(inception_v1.inception_v1_arg_scope()):
+                _, endpoints = inception_v1.inception_v1(
+                    x,
+                    num_classes=1001,
+                    is_training=False,
+                    spatial_squeeze=False,
+                )
+        return [endpoints[name] for name in layer_names]
+
+    # Build variables by a dummy call
+    _ = forward_fn(tf.zeros([1, 224, 224, 3], dtype=tf.float32))
+
+    ckpt_path = _download_checkpoint_if_needed(weights_path)
+    var_list = tf.compat.v1.get_collection(
+        tf.compat.v1.GraphKeys.GLOBAL_VARIABLES, scope=scope_name
+    )
+    name_map = {v.name.split(":")[0]: v for v in var_list}
+    ckpt = tf.train.Checkpoint(**name_map)
+    ckpt.restore(ckpt_path).expect_partial()
+
+    return forward_fn, _preprocess_fn
+

vgg16_mlx.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1d1d8874dae6011833ea67e5e3613c8575ec61eac7af3ca4b49a22e8c85ad8bd
+size 553438706

vgg19_mlx.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1c56855e8cf3337ad42a45b15545c8dfb60aaed23d57295101e9f1e9cb1a3429
+size 574679086