Cleanup: Remove obsolete scripts and int8 weights

alexnet_places365.pth_mlx.npz

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

export_all_bf16.py

@@ -1,56 +0,0 @@
-"""
-Export all supported models to MLX .npz format in bfloat16 (bf16) for 50% size reduction.
-Requires torch, torchvision, numpy.
-"""
-
-import os
-import numpy as np
-import torch
-import torchvision.models as models
-
-def export_model(model_name, model_fn, weights_enum):
-    print(f"Exporting {model_name} (bf16)...")
-    model = model_fn(weights=weights_enum)
-    model.eval()
-    
-    state = model.state_dict()
-    converted_state = {}
-    
-    for k, v in state.items():
-        # Convert to numpy float16 (bfloat16 is not fully standard in numpy saving, 
-        # but MLX handles float16 perfectly. We will save as float16 for simplicity 
-        # and broad compatibility, or we can try casting to bfloat16 if numpy supports it 
-        # or just save as float16 which is also 2 bytes).
-        # Actually, numpy doesn't fully support bfloat16 serialization widely yet.
-        # float16 is the standard "half".
-        # DeepDream doesn't need bf16 dynamic range usually. float16 is fine.
-        v_np = v.cpu().detach().numpy().astype(np.float16)
-        converted_state[k] = v_np
-
-    out_name = f"{model_name}_mlx_bf16.npz" # Naming it bf16/fp16 to imply half precision
-    # But wait, let's stick to what the user asked "bf16".
-    # MLX load_npz will load it as float16. 
-    
-    np.savez(out_name, **converted_state)
-    
-    original_size = sum(v.numel() * 4 for v in state.values()) / (1024*1024)
-    new_size = os.path.getsize(out_name) / (1024*1024)
-    
-    print(f"✅ Saved {out_name}")
-    print(f"   Size: {new_size:.1f} MB (Original float32: ~{original_size:.1f} MB)")
-
-def main():
-    # 1. VGG16
-    export_model("vgg16", models.vgg16, models.VGG16_Weights.IMAGENET1K_V1)
-    
-    # 2. VGG19
-    export_model("vgg19", models.vgg19, models.VGG19_Weights.IMAGENET1K_V1)
-    
-    # 3. GoogLeNet
-    export_model("googlenet", models.googlenet, models.GoogLeNet_Weights.IMAGENET1K_V1)
-    
-    # 4. ResNet50
-    export_model("resnet50", models.resnet50, models.ResNet50_Weights.IMAGENET1K_V1)
-
-if __name__ == "__main__":
-    main()

export_googlenet_npz.py

@@ -1,21 +0,0 @@
-"""
-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_models.py

@@ -1,93 +0,0 @@
-"""
-Unified export script for converting PyTorch models to MLX .npz format.
-Supports VGG16, VGG19, GoogLeNet, and ResNet50.
-Handles both float32 (default) and float16/bfloat16 (efficient) exports.
-
-Usage:
-    python export_models.py --model all --dtype float16
-    python export_models.py --model vgg16
-"""
-
-import argparse
-import os
-import numpy as np
-import torch
-import torchvision.models as models
-
-def get_model_info(model_name):
-    if model_name == "vgg16":
-        return models.vgg16, models.VGG16_Weights.IMAGENET1K_V1
-    elif model_name == "vgg19":
-        return models.vgg19, models.VGG19_Weights.IMAGENET1K_V1
-    elif model_name == "googlenet":
-        return models.googlenet, models.GoogLeNet_Weights.IMAGENET1K_V1
-    elif model_name == "resnet50":
-        return models.resnet50, models.ResNet50_Weights.IMAGENET1K_V1
-    else:
-        raise ValueError(f"Unknown model: {model_name}")
-
-def export_model(model_name, dtype="float32"):
-    print(f"Exporting {model_name} ({dtype})...")
-    model_fn, weights = get_model_info(model_name)
-    model = model_fn(weights=weights)
-    model.eval()
-    
-    state = model.state_dict()
-    converted_state = {}
-    
-    target_type = np.float32
-    suffix = ""
-    quantize_int8 = False
-    
-    if dtype in ["float16", "bf16", "half"]:
-        target_type = np.float16
-        suffix = "_bf16" # Keep legacy suffix for compatibility with dream.py logic
-    elif dtype == "int8":
-        target_type = np.float16 # Base type for scales/biases
-        suffix = "_int8"
-        quantize_int8 = True
-    
-    for k, v in state.items():
-        v_np = v.cpu().detach().numpy()
-        
-        if quantize_int8 and "weight" in k and v_np.ndim >= 2:
-            # Quantize to INT8
-            v_abs = np.abs(v_np)
-            v_max = np.max(v_abs)
-            
-            # Scale to range [-127, 127]
-            # Avoid div by zero
-            if v_max == 0:
-                scale = 1.0
-            else:
-                scale = v_max / 127.0
-            
-            v_int8 = (v_np / scale).astype(np.int8)
-            
-            converted_state[f"{k}_int8"] = v_int8
-            converted_state[f"{k}_scale"] = np.array(scale).astype(target_type)
-        else:
-            converted_state[k] = v_np.astype(target_type)
-
-    out_name = f"{model_name}_mlx{suffix}.npz"
-    np.savez(out_name, **converted_state)
-    
-    original_size = sum(v.numel() * 4 for v in state.values()) / (1024*1024)
-    new_size = os.path.getsize(out_name) / (1024*1024)
-    
-    print(f"✅ Saved {out_name}")
-    print(f"   Size: {new_size:.1f} MB (Original: ~{original_size:.1f} MB)")
-
-def main():
-    parser = argparse.ArgumentParser(description="Export PyTorch models to MLX")
-    parser.add_argument("--model", choices=["vgg16", "vgg19", "googlenet", "resnet50", "all"], default="all")
-    parser.add_argument("--dtype", choices=["float32", "float16", "bf16", "int8"], default="float16", help="Output data type")
-    args = parser.parse_args()
-    
-    models_to_export = ["vgg16", "vgg19", "googlenet", "resnet50"] if args.model == "all" else [args.model]
-    
-    for m in models_to_export:
-        export_model(m, args.dtype)
-
-if __name__ == "__main__":
-    main()

export_resnet50_npz.py

@@ -1,23 +0,0 @@
-"""
-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

@@ -1,23 +0,0 @@
-"""
-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

@@ -1,23 +0,0 @@
-"""
-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_int8.npz

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

resnet50_mlx_int8.npz

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

resnet50_places365.pth_mlx.npz

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

tf_inception_v1.py

@@ -1,79 +0,0 @@
-"""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
-

train_dream.py

@@ -1,30 +0,0 @@
-# TODO: Implement Fine-Tuning Logic
-
-"""
-DeepDream Training / Fine-Tuning Script (Placeholder)
-
-Goal:
-Allow users to fine-tune these base models (VGG, GoogLeNet, etc.) on their own datasets
-to create custom Dream styles.
-
-Steps to Implement:
-1.  Load Dataset: Use `torchvision.datasets.ImageFolder` or custom loader for user images.
-2.  Load Model: Use our MLX models (need to add `train()` mode with dropout/grad support if missing,
-    or simpler: use PyTorch for training -> export to MLX).
-    *Easier path:* Train in PyTorch using standard scripts, then use `export_*.py` to bring it here.
-3.  Training Loop: Standard classification training or style transfer fine-tuning.
-4.  Export: Save the fine-tuned weights to `.pth`, then run export script.
-
-Usage:
-    python train_dream.py --data /path/to/images --epochs 10 --model vgg16
-"""
-
-import argparse
-
-def main():
-    print("--- DeepDream-MLX Training Stub ---")
-    print("Feature coming soon.")
-    print("Current Workflow: Train in PyTorch -> Use export_*.py -> Dream in MLX")
-
-if __name__ == "__main__":
-    main()

vgg16_mlx_int8.npz

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

vgg19_mlx_int8.npz

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