AVOID — Stale and unlicensed — last commit 3y ago

• 16 active contributors
• ⚠ Stale — last commit 3y ago
• ⚠ Concentrated ownership — top contributor handles 54% of recent commits
• ⚠ No license — legally unclear to depend on
• ⚠ No CI workflows detected
• ⚠ No test directory detected
• ⚠ Scorecard: marked unmaintained (0/10)
• ⚠ Scorecard: default branch unprotected (0/10)

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests + OpenSSF Scorecard}

A TensorFlow-based CNN implementation that applies artistic style transfer to images and videos in real-time (~100ms per Titan X frame). It combines feed-forward networks with perceptual loss functions to enable fast neural style transfer, avoiding the slow iterative optimization of traditional methods. Users input a content image/video and a style image, and the network transforms the content to match the artistic style of the painting. Dual-script entry points: style.py (image stylization) and transform_video.py (video frame processing). Core logic in src/ with separate modules: optimize.py (training), transform.py (inference/feed-forward network), vgg.py (pre-trained perceptual loss VGG19), and utils.py (helpers). Examples directory contains sample content/style images and pre-computed results. Evaluation via evaluate.py.

Machine learning researchers and practitioners who want to apply neural artistic style transfer to visual media without waiting minutes per image. Artists and content creators building style-transfer applications who need speed over quality trade-offs. Computer vision students studying perceptual loss functions and CNN architectures.

Moderately mature but aging. The codebase is from 2016 (based on license text and CNN architecture choices) with a small Python codebase (~28K lines). No visible CI/CD pipeline in the file structure (.github contains only FUNDING.yml). The project appears maintenance-mode: no recent activity indicators visible, and it uses older TensorFlow patterns (not TF 2.x eager execution based on file names). Suitable for research/educational use but not actively developed.

Single-author project (Logan Engstrom) with restrictive licensing (contact required for commercial use, limited to academic research). No test suite visible in the file structure. TensorFlow dependency is likely pinned to TF 1.x APIs given the src/vgg.py and src/optimize.py architecture patterns from 2016. Dependency on pre-trained VGG weights (loaded in src/vgg.py) adds external data dependency. No visible package.json or requirements.txt with pinned versions in the file list.

Unable to determine active work from file structure alone. No visible recent commits, active PRs, or GitHub Actions workflows (.github/workflows/ not present). Project appears to be in archive/reference state rather than active development.

git clone https://github.com/lengstrom/fast-style-transfer.git
cd fast-style-transfer
bash setup.sh
python style.py --content examples/content/chicago.jpg --style examples/style/udnie.jpg --output result.jpg

Daily commands: For image stylization: python style.py --content <image_path> --style <style_path> --output <output_path>. For video: python transform_video.py --input <video_path> --style <style_path> --output <output_path>. Specific flags and model paths likely documented in evaluate.py and the root-level scripts.

• style.py — Main entry point for training style transfer models; orchestrates the entire training pipeline using the transform network and loss computation.
• src/transform.py — Defines the feed-forward convolutional neural network architecture that performs real-time style transfer; core model definition.
• src/optimize.py — Implements the training loop, loss functions (perceptual and style losses), and optimization logic using VGG19 features.
• src/vgg.py — VGG19 network loader that extracts perceptual features for loss computation; critical dependency for style transfer quality.
• evaluate.py — Inference script that applies trained style transfer models to images; the primary user-facing evaluation interface.
• transform_video.py — Video stylization utility that applies style transfer frame-by-frame; extends core functionality to video domain.
• src/utils.py — Utility functions for image loading, preprocessing, and tensor conversions; shared across training and inference.

• style.py (TensorFlow, argparse) — Orchestrates training loop; manages dataset loading, checkpoint saving, and loss logging
  • Failure mode: Missing dataset path or style image → immediate crash; corrupted checkpoint → training restart required
• src/transform.py (TensorFlow layers API) — Defines the feed-forward CNN architecture; implements residual blocks and instance normalization
  • Failure mode: Incorrect tensor shapes → shape mismatch errors; instance norm bugs → poor style transfer quality
• src/optimize.py (TensorFlow, VGG19) — Computes perceptual loss (via VGG19) and style loss (Gram matrix); updates model via Adam
  • Failure mode: VGG weights not loaded → KeyError; loss NaNs → training divergence; incorrect layer selection → poor quality
• src/vgg.py (TensorFlow, pre-trained weights) — Loads pre-trained VGG19; extracts intermediate features for perceptual loss computation
  • Failure mode: Checkpoint URL unreachable → download fails; wrong layer names → feature extraction breaks
• evaluate.py (TensorFlow, Pillow) — Loads trained model checkpoint and applies it to input images; manages inference IO
  • Failure mode: Checkpoint not found → cannot restore model; input image too large → memory OOM; corrupted image → decoding fails
• src/utils.py (NumPy, Pillow) — Handles image I/O, normalization/denormalization, and tensor shape utilities
  • Failure mode: Unsupported image format →

Train a new style transfer model

1. Prepare training dataset with content images in one directory and style image(s) in another (README.md)
2. Modify style.py to set hyperparameters: learning rate, style weight, content weight, num_epochs, batch_size (style.py)
3. Run training: python style.py --style path/to/style.jpg --dataset path/to/dataset --checkpoint-dir models/ (style.py)
4. Monitor loss convergence in src/optimize.py; loss functions compute VGG-based perceptual and style losses (src/optimize.py)

Apply style transfer to new images

1. Ensure a trained model checkpoint exists in the models/ directory (evaluate.py)
2. Run inference: python evaluate.py --checkpoint models/style.ckpt --input input.jpg --output output.jpg (evaluate.py)
3. Image preprocessing and denormalization handled by src/utils.py load_img() and save_img() (src/utils.py)

Modify the style transfer network architecture

1. Edit src/transform.py; define new conv/residual blocks, adjust instance normalization, or change upsampling strategy (src/transform.py)
2. Update style.py to instantiate the modified network via src/transform.py (style.py)
3. Verify loss computation in src/optimize.py remains compatible with new output shapes (src/optimize.py)
4. Re-train using style.py with the same command-line interface (style.py)

Stylize videos frame-by-frame

1. Prepare video file (MP4, etc.) and a trained checkpoint (transform_video.py)
2. Run: python transform_video.py --checkpoint models/style.ckpt --input video.mp4 --output output.mp4 (transform_video.py)
3. Video processing iterates over frames; each frame passes through the transform network and is reassembled (transform_video.py)

• TensorFlow — Industry-standard deep learning framework with efficient GPU support; enables fast CNN inference and training at scale.
• VGG19 (pre-trained) — Proven perceptual feature extractor for style transfer; captures style and content in different layers for loss computation.
• Instance Normalization — Stabilizes training and improves style transfer quality; decouples style from content during inference.
• Residual Blocks — Enables deeper networks without vanishing gradients; improves detail preservation during stylization.

• Single feed-forward network instead of iterative optimization

  • Why: Achieves 100ms inference on high-res images; trade-off is style transfer quality vs. speed (iterative methods slower but higher quality).
  • Consequence: Fast real-time stylization but may lose fine artistic details compared to optimization-based approaches.

• Pre-trained VGG19 (ImageNet) for perceptual loss instead of training from scratch

  • Why: Leverages existing semantic understanding; avoids expensive retraining.
  • Consequence: Perceptual loss tied to ImageNet domain; may not generalize optimally to non-photographic content.

• Per-style model vs. universal style network

  • Why: Simpler architecture, faster inference; trade-off is training cost per style.
  • Consequence: Each new style requires 10+ hours training; no single model handles multiple styles.

• Instance normalization instead of batch normalization

  • Why: Better style transfer quality; normalization independent of batch statistics.
  • Consequence: Batch size has minimal effect on training; slightly higher memory per sample.

• Real-time style transfer does not handle semantic segmentation or content-aware style transfer
• No interactive UI provided; CLI-only interface
• Does not support arbitrary color space conversions (RGB only)
• No temporal coherence optimization for videos (frame-by-frame independent)
• Does not implement neural style transfer via iterative optimization (only feed-forward)
• No built-in model quantization or mobile optimization

VGG19 pre-trained weights are likely downloaded automatically on first run (common TensorFlow pattern) but not included in repo; internet access required. TensorFlow 1.x session/placeholder API assumed; code will fail or need porting on TF 2.x without tf.compat.v1. No visible input validation: extremely large images or edge-case aspect ratios may cause memory errors or silent failures. Model expects 3-channel RGB images; grayscale or RGBA inputs will silently fail or produce artifacts. Video processing likely hardcodes codec/fps assumptions that may break on unusual video formats. No visible conda/pip requirements.txt: Python and TensorFlow versions are unconstrained, risking dependency hell.

• Perceptual Loss (Gram Matrix Loss) — This repo's core innovation: instead of pixel-space L2 loss, it matches high-level CNN feature statistics (Gram matrices) for style and low-level activations for content, enabling artistic transfer without pixel-perfect reconstruction.
• Feed-Forward Transformer Network — The repo trains a single-pass CNN to approximate the iterative optimization of slow style transfer; this architectural pattern (vs. pixel optimization) is why inference is 100ms instead of minutes.
• Instance Normalization — Ulyanov's technique used in src/transform.py instead of batch norm; critical for style transfer because it normalizes per-instance instead of across batch, preserving style diversity across images.
• VGG Pre-trained Features — src/vgg.py loads a frozen VGG19 trained on ImageNet; its intermediate layers serve as a fixed perceptual metric to define what 'artistic style' means without training new features.
• Style Transfer via Texture Synthesis — Gatys et al.'s foundational insight (matching Gram matrices of activations) that this repo implements; separates content (CNN activations) from style (feature correlation statistics).
• Residual Connections (Implied) — Modern CNNs for style transfer use skip connections to preserve content structure; likely used in src/transform.py's encoder-decoder design to avoid bottleneck information loss.
• Optical Flow / Frame Consistency — transform_video.py processes each frame independently, risking flicker artifacts; understanding temporal coherence and motion compensation is essential for production video style transfer.

• tensorflow/magenta — Google's magenta library includes style-transfer models and NSynth; shares TensorFlow ecosystem and perceptual-loss research origins.
• jcjohns/neural-style — Justin Johnson's original slow neural style transfer (Torch); this repo's primary inspiration and predecessor that motivated the feed-forward approach.
• openai/stylegan — Modern generative approach to style control; later work in neural style synthesis for reference on architectural evolution.
• AliaksandrSiarohin/first-order-motion-model — Video stylization with motion coherence; extends beyond frame-independent stylization with temporal consistency.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add unit tests for src/utils.py, src/vgg.py, and src/transform.py

The repo lacks any test files despite having core utility modules. Testing the image preprocessing in utils.py, VGG model loading in vgg.py, and the style transfer transformation logic in transform.py would catch regressions and make contributions safer. This is especially important for a CNN model where numerical correctness matters.

• [ ] Create tests/test_utils.py with tests for image loading, preprocessing, and any utility functions in src/utils.py
• [ ] Create tests/test_vgg.py to verify VGG model initialization and weight loading from src/vgg.py
• [ ] Create tests/test_transform.py to test the transformation pipeline in src/transform.py with sample images
• [ ] Add pytest to setup.sh or requirements.txt and document how to run tests in README.md

Add GitHub Actions CI workflow for automated testing and model validation

The .github/FUNDING.yml exists but there are no CI workflows. Adding automated tests on push/PR would validate that style.py, evaluate.py, and transform_video.py work correctly across commits. This prevents breaking changes and ensures pre-trained models load correctly.

• [ ] Create .github/workflows/test.yml to run pytest on src/ modules for each Python 3.x version
• [ ] Add a workflow step to validate that evaluate.py runs without errors on example images (examples/content/stata.jpg)
• [ ] Add a workflow step to test transform_video.py loads and processes a short test video clip
• [ ] Document the CI setup in docs.md or README.md

Create comprehensive API documentation for src/transform.py and src/optimize.py with usage examples

The README shows high-level usage but docs.md is sparse. The core style transfer logic in transform.py and the optimization training logic in optimize.py lack docstring documentation and usage examples. New contributors cannot easily understand the architecture or extend the code.

• [ ] Add detailed docstrings to all functions in src/transform.py explaining the style transfer pipeline, input/output formats, and parameters
• [ ] Add detailed docstrings to src/optimize.py explaining the training loop, loss functions, and checkpointing mechanism
• [ ] Add a 'Developer Guide' section to docs.md with code examples showing how to use src/transform.py for custom inference
• [ ] Add a 'Training Your Own Model' section to docs.md with example commands using src/optimize.py, referencing examples/style/

• Add a comprehensive requirements.txt with pinned TensorFlow 1.x version and all transitive dependencies; currently missing from repo and blocks reproducibility. Document minimum Python version.
• Implement unit tests for src/utils.py image I/O functions (load_image, save_image, etc.) that verify correct shape/dtype/range outputs for standard and edge-case inputs (very small images, unusual aspect ratios, 16-bit PNGs).
• Create a step-by-step training tutorial in docs.md with exact command-line invocations to train a new style model from scratch; currently only evaluate.py exists but is undocumented. Include expected epoch count and loss curve baseline.
• Add GPU/CPU device selection CLI flag to style.py and transform_video.py (currently hardcoded or implicit); users with CPU-only machines or multiple GPUs cannot control device placement.
• Port inference code (style.py, src/transform.py) to TensorFlow 2.x eager execution and create a simple tf.saved_model export; would unblock modern deployment patterns.

The fast-style-transfer project has moderate security concerns, primarily due to missing dependency management visibility, lack of input validation on file operations, and potential model loading vulnerabilities. The project appears to be a research/ML tool without visible deployment infrastructure. For local use, risks are lower; however, if deployed as a service, critical gaps in input validation, dependency management, and resource limiting need to be addressed. The absence of a requirements file makes it impossible to assess if outdated or vulnerable packages are being used. Implementing strict input validation, dependency pinning, and resource limits should be prioritized.

• High · Missing Dependency Management File — Root directory / Package management. No requirements.txt, setup.py, Pipfile, or pyproject.toml file is visible in the provided file structure. This makes it impossible to verify if the project uses secure versions of its dependencies (TensorFlow, OpenCV, etc.). Without explicit dependency pinning, the project is vulnerable to transitive dependency attacks and known vulnerabilities in outdated packages. Fix: Create and maintain a requirements.txt or setup.py file with pinned versions of all dependencies. Use tools like pip-audit or safety to regularly check for known vulnerabilities in dependencies. Consider using a lock file (pip-compile, Poetry) for reproducible builds.
• Medium · Potential Arbitrary File Access in Media Processing — evaluate.py, transform_video.py, src/transform.py. The codebase processes user-supplied media files (images/videos) through TensorFlow models without visible input validation. Files like evaluate.py and transform_video.py likely accept file paths as input. Insufficient path validation could allow directory traversal attacks (e.g., '../../../etc/passwd') or access to sensitive files outside intended directories. Fix: Implement strict input validation for file paths. Use os.path.abspath() and verify the resolved path is within an allowed directory. Use whitelisting for allowed file extensions (.jpg, .png, .mp4). Never directly pass user input to file operations without sanitization.
• Medium · Potential Deserialization/Model Loading Vulnerabilities — src/optimize.py, src/transform.py, src/vgg.py, style.py. The project loads pre-trained TensorFlow models. If models are loaded from untrusted sources or user-supplied locations without verification, it could enable arbitrary code execution through malicious model files or pickled Python objects embedded in checkpoint files. Fix: Only load models from trusted sources. Implement model signature verification using checksums (SHA-256). Never load models from user-supplied paths directly. Use TensorFlow's SavedModel format with signature definitions rather than pickled Python objects. Validate model integrity before loading.
• Medium · Missing Input Size/Resource Limits — evaluate.py, transform_video.py, src/transform.py. No visible checks for maximum input image/video dimensions or processing time limits. An attacker could provide extremely large or malformed media files to cause Denial of Service (DoS) through excessive memory consumption or CPU usage. Fix: Implement size limits for input images/videos (max dimensions, max file size). Add timeouts for processing operations. Rate-limit API endpoints if exposed. Monitor resource usage and implement graceful degradation or rejection of oversized inputs.
• Low · No HTTPS/TLS Configuration Visible — setup.sh, deployment configuration (not provided). If this project is deployed as a web service, there's no visible configuration for HTTPS, TLS certificates, or security headers. The README and docs don't mention deployment security practices. Fix: If deployed as a web service, enforce HTTPS/TLS with proper certificate management. Add security headers (Content-Security-Policy, X-Frame-Options, etc.). Use environment variables for sensitive configuration rather than hardcoding.
• Low · No Visible Output Sanitization — evaluate.py, transform_video.py, style.py. The project outputs styled images/videos to the filesystem. Without proper output validation, there could be risks if output files are served over the web without appropriate MIME type headers or if filenames contain user input. Fix: Sanitize output filenames to prevent directory traversal. Set appropriate MIME types when serving output files. Validate output integrity before returning to users. Consider storing outputs in isolated directories with restricted permissions.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/lengstrom/fast-style-transfer shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live lengstrom/fast-style-transfer repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/lengstrom/fast-style-transfer.

What it runs against: a local clone of lengstrom/fast-style-transfer — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in lengstrom/fast-style-transfer | Confirms the artifact applies here, not a fork | | 2 | Default branch master exists | Catches branch renames | | 3 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 4 | Last commit ≤ 1061 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of lengstrom/fast-style-transfer. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/lengstrom/fast-style-transfer.git
#   cd fast-style-transfer
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of lengstrom/fast-style-transfer and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "lengstrom/fast-style-transfer(\\.git)?\\b" \\
  && ok "origin remote is lengstrom/fast-style-transfer" \\
  || miss "origin remote is not lengstrom/fast-style-transfer (artifact may be from a fork)"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "style.py" \\
  && ok "style.py" \\
  || miss "missing critical file: style.py"
test -f "src/transform.py" \\
  && ok "src/transform.py" \\
  || miss "missing critical file: src/transform.py"
test -f "src/optimize.py" \\
  && ok "src/optimize.py" \\
  || miss "missing critical file: src/optimize.py"
test -f "src/vgg.py" \\
  && ok "src/vgg.py" \\
  || miss "missing critical file: src/vgg.py"
test -f "evaluate.py" \\
  && ok "evaluate.py" \\
  || miss "missing critical file: evaluate.py"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 1061 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1031d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/lengstrom/fast-style-transfer"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.