WAIT — Stale — last commit 5y ago

• 2 active contributors
• Other licensed
• ⚠ Stale — last commit 5y ago
• ⚠ Small team — 2 contributors active in recent commits
• ⚠ Single-maintainer risk — top contributor 97% of recent commits
• ⚠ Non-standard license (Other) — review terms
• ⚠ 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}

SIDGAN is a CycleGAN-based framework for low-light video enhancement that uses intermediate domain mapping to synthesize realistic training data. It maps normal-light videos (Vimeo) → long-exposure raw frames (SID Motion) → short-exposure low-light frames through two separate CycleGAN pipelines, enabling synthetic data generation for training enhancement models without paired ground-truth labels. Monolithic structure: train_cyclegan_a2b.py and train_cyclegan_b2c.py are entry points that orchestrate two-stage domain mapping. Core CycleGAN implementation in src/CycleGAN.py, generator/discriminator architectures in models/ (unet.py, ICCV_architectures.py), data loading in utilities/data_loader.py. Results and checkpoints save to experiments/$EXP_NAME/.

Computer vision researchers and practitioners working on low-light video restoration who need to train enhancement models without large paired datasets. Specifically useful for those studying domain adaptation, synthetic data generation, and video enhancement in ECCV/ICCV conference contexts.

Actively maintained research code tied to ECCV 2020 publication. The repository is the author's personal fork of Huawei Noah's official implementation. Minimal test coverage and no CI/CD visible in the file structure; typical for academic research. Code appears stable but not production-hardened.

Standard open source risks apply.

No active development visible. This is a static research artifact published with ECCV 2020. The official Huawei Noah repository (linked in README) is the primary maintained version; this is the author's personal research copy.

git clone https://github.com/sjmoran/low-light-video-enhancement.git
cd low-light-video-enhancement
conda create -n sidganenv python=3.5
conda activate sidganenv
pip install -r requirements.txt
# Download SID_long, VBM4D_rawRGB, vimeo to $PATH_TO_DATA
python train_cyclegan_a2b.py --data_root $PATH_TO_DATA --project_root $(pwd) --name exp1

Daily commands: For A→B mapping (Vimeo to SID long-exposure): python train_cyclegan_a2b.py --data_root /path/to/data --project_root /path/to/code --name experiment_name. For B→C mapping (SID long to short-exposure): python train_cyclegan_b2c.py --data_root /path/to/data --project_root /path/to/code --name experiment_name. Results appear in experiments/experiment_name/{images,saved_models,log,meta_data.json}.

• train_cyclegan_a2b.py — Entry point for training the first CycleGAN stage (normal→intermediate domain); must understand this to run the full pipeline
• train_cyclegan_b2c.py — Entry point for training the second CycleGAN stage (intermediate→enhanced domain); completes the two-stage synthesis strategy
• src/CycleGAN.py — Core CycleGAN architecture and training loop; implements the intermediate domain mapping logic central to SIDGAN
• models/ICCV_architectures.py — Generator and discriminator network definitions; any model changes or architecture exploration starts here
• utilities/data_loader.py — Data pipeline for loading video frames and domain pairs; critical for understanding how training data flows through the system
• requirements.txt — Freezes TensorFlow 1.15 and Keras 2.3 dependency chain; legacy stack requires exact version compatibility
• README.md — Documents SIDGAN's two-stage CycleGAN approach and links to paper; establishes conceptual framework for all code

• CycleGAN core (TensorFlow/Keras, custom training loop) — Manages generator and discriminator training, cycle consistency loss computation, checkpoint saving/loading
  • Failure mode: Divergent losses if learning rate too

Add a new generator architecture variant

1. Define new generator class in models/ICCV_architectures.py following the encoder-decoder pattern with skip connections (models/ICCV_architectures.py)
2. Update src/CycleGAN.py to accept the new generator type in init and instantiate it for both G_A2B and G_B2C (src/CycleGAN.py)
3. Test the new architecture by modifying train_cyclegan_a2b.py to pass the new generator class to CycleGAN() (train_cyclegan_a2b.py)

Integrate a custom video dataset

1. Create dataset-specific loading logic in utilities/data_loader.py, extending the existing load_data function to handle your frame directory structure (utilities/data_loader.py)
2. Update train_cyclegan_a2b.py and train_cyclegan_b2c.py to call your new data loader with correct paths to domains A, B, and C (train_cyclegan_a2b.py)
3. Adjust batch size and data augmentation parameters in the training scripts based on your dataset size (train_cyclegan_b2c.py)

Modify training hyperparameters or loss weights

1. Open src/CycleGAN.py and locate the init method; adjust learning_rate, lambda_cycle, lambda_identity, and other loss weights (src/CycleGAN.py)
2. Update train_cyclegan_a2b.py and train_cyclegan_b2c.py to pass new hyperparameter values when instantiating CycleGAN (train_cyclegan_a2b.py)
3. Run training with modified parameters and monitor validation metrics to evaluate impact (train_cyclegan_b2c.py)

Add new loss function or regularization term

1. Define the new loss computation in src/CycleGAN.py within the train_on_batch or a new method (src/CycleGAN.py)
2. Update the total loss aggregation to include the new term with a configurable weight parameter (src/CycleGAN.py)
3. Pass the loss weight as a hyperparameter from train_cyclegan_a2b.py or train_cyclegan_b2c.py (train_cyclegan_a2b.py)

• TensorFlow 1.15.0 + Keras 2.3.1 — Paper was developed with this stack; legacy version ensures reproducibility; static graphs provide optimization opportunities for video processing
• CycleGAN (cycle consistency loss) — Enables unpaired domain-to-domain translation without pixel-level ground truth; core innovation of SIDGAN is using intermediate domain as a synthetic bridge
• OpenCV + NumPy — Efficient video frame I/O and batch image preprocessing; standard for computer vision pipelines
• Two-stage training (A→B→C) — Intermediate domain mapping improves quality over direct low-light to enhanced mapping; reduces synthetic data artifacts

• Two-stage CycleGAN pipeline instead of end-to-end

  • Why: Intermediate domain provides more semantically meaningful supervision signal; reduces domain gap
  • Consequence: Requires training two separate models sequentially, doubling training time; added complexity for inference

• CycleGAN with unpaired images instead of supervised learning

  • Why: No paired low-light/enhanced video ground truth available; CycleGAN works with domain-level statistics only
  • Consequence: May struggle with specific content details; relies on cycle consistency as sole supervision signal

• Legacy TensorFlow 1.15 / Keras 2.3

  • Why: Matches paper publication environment; ensures exact reproducibility
  • Consequence: Cannot use modern TF 2.x features, eager execution, or latest performance optimizations; dependencies difficult to resolve on newer systems

• Image pooling history buffer for discriminators

  • Why: Stabilizes adversarial training by reducing discriminator overfitting to recent generated samples
  • Consequence: Adds memory overhead; training slower but more stable

• Real-time inference on video streams (batch processing only)
• Mobile/edge deployment (GPU-only code path, no quantization)
• Handling video with motion estimation or temporal coherence constraints (frame-by-frame processing)
• Unsupervised quality metrics or automatic parameter tuning
• Multi-GPU distributed training support

1. Dataset dependency: Training requires manual download and precise folder structure (SID_long, VBM4D_rawRGB, vimeo under $PATH_TO_DATA); missing data will cause silent failures in the data loader. 2. Deprecated TensorFlow 1.15: Requires GPU driver compatibility with TF 1.x; TF 2.x is incompatible with this codebase. 3. Two-stage pipeline: Must successfully complete A→B training before B→C; checkpoints and intermediate outputs are essential. 4. Python 3.5 conda specification: Modern systems may reject this; Python 3.6-3.7 likely works but untested. 5. No validation split: Training scripts don't show validation metrics; only test via saved model inference.

• CycleGAN (Cycle-Consistent Adversarial Networks) — Core algorithm enabling unpaired image-to-image translation; allows SIDGAN to map between domains (Vimeo, SID long, SID short) without paired ground truth, making synthetic data generation feasible
• Intermediate Domain Mapping — SIDGAN's key innovation: breaking Vimeo→SID short into Vimeo→SID long→SID short reduces domain gap and improves translation quality versus direct one-stage mapping
• Instance Normalization — Replaces batch norm in generators to remove batch-dependent statistics that harm unpaired translation; critical for stable CycleGAN training in utilities/instance_normalization.py
• Image History Buffer (Replay Buffer) — Implemented in utilities/image_pool.py; prevents discriminator from overfitting to recent generated samples and mitigates mode collapse in adversarial training
• U-Net Architecture — Generator backbone in models/unet.py with skip connections; preserves low-level image details (colors, textures) during translation while allowing high-level semantic changes
• Cycle-Consistency Loss — Enforces F(G(x)) ≈ x (forward-backward reconstruction); enables unsupervised learning by penalizing non-invertible translations without paired labels
• Synthetic Data Generation for Domain Adaptation — SIDGAN's application: generate realistic low-light training pairs without expensive ground-truth labeling, then train enhancement models on synthetic→real distribution shift

• junyanz/pytorch-CycleGAN — Reference PyTorch CycleGAN implementation; this repo adapts the approach to TensorFlow/Keras for low-light video domain mapping
• cchen156/Seeing-Motion-in-the-Dark — Source of the SID Motion dataset used for domain B in SIDGAN's two-stage mapping; provides raw short/long-exposure frame pairs
• huawei-noah/noah-research — Official Huawei repository containing the primary maintained SIDGAN implementation; this is the author's personal research fork
• thinkongithub/SID — Original SID dataset (Seeing in the Dark); predecessor work that inspired the low-light enhancement problem SIDGAN addresses
• aiff22/EnhanceNet-Code — Single-image super-resolution via perceptual loss; related adversarial training approach for image enhancement tasks

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 dependency compatibility layer for TensorFlow 2.x support

The repo pins TensorFlow 1.15.0 and Keras 2.3.1 (both EOL since 2020). These versions have known security vulnerabilities and won't run on Python 3.9+. Creating a compatibility shim would allow users to run the code on modern environments. This is critical since the paper is from 2020 and users today cannot easily reproduce results.

• [ ] Create src/tf_compat.py with wrapper functions for deprecated TensorFlow 1.x APIs used in src/CycleGAN.py and models/
• [ ] Update requirements.txt to support tensorflow>=2.4 with conditional imports in src/CycleGAN.py, src/train_cycleGAN.py, and models/ICCV_architectures.py
• [ ] Add a MIGRATION.md documenting breaking changes and testing on TensorFlow 2.x

Add end-to-end inference pipeline and model loading tests

No test files exist in the repo. The codebase has training scripts (train_cyclegan_a2b.py, train_cyclegan_b2c.py) and models/, but no verification that pre-trained models can be loaded and used for inference. New contributors cannot validate that the pipeline works end-to-end.

• [ ] Create tests/test_inference.py with fixtures that load pre-trained models from models/ and run inference on sample frames from images/
• [ ] Create tests/test_data_loading.py to validate utilities/data_loader.py with mock video data
• [ ] Add a GitHub Actions workflow (.github/workflows/test.yml) that runs pytest on push to main

Extract and document training configuration into a YAML/JSON config file

Currently train_cyclegan_a2b.py and train_cyclegan_b2c.py have hardcoded hyperparameters scattered throughout. This makes reproducibility difficult and prevents easy ablation studies. A centralized config schema would improve usability.

• [ ] Create configs/sidgan_config.yaml with documented parameters for both A→B and B→C domain mappings (learning rate, batch size, epochs, etc.)
• [ ] Refactor train_cyclegan_a2b.py and train_cyclegan_b2c.py to accept a --config argument using argparse and load from the YAML file
• [ ] Add a configs/README.md explaining each parameter and providing examples for different hardware setups

• Add unit tests for utilities/data_loader.py with mock SID Motion and Vimeo frames to verify video batching and frame extraction logic handles edge cases (single-frame videos, mismatched dimensions).
• Create a standalone inference script (e.g., infer.py) that loads trained checkpoints from experiments/ and applies A→B→C enhancement to a low-light video file, since only training code is present.
• Add logging and visualization for cycle-consistency loss and generator/discriminator loss curves in real-time (e.g., via tensorboard), currently only saved to log/ without a viewing utility.

This codebase has significant security concerns due to severely outdated dependencies with multiple known CVEs. TensorFlow 1.15.0, Keras 2.3.1, and Pillow 8.1.2 are all no longer maintained and

• High · Outdated TensorFlow with Known Vulnerabilities — requirements.txt. tensorflow_gpu==1.15.0 is severely outdated (released in 2019) and contains multiple known CVEs including arbitrary code execution, denial of service, and information disclosure vulnerabilities. TensorFlow 1.15 reached end-of-life and is no longer receiving security patches. Fix: Upgrade to TensorFlow 2.x (latest stable version, e.g., tensorflow>=2.13.0). Review code for compatibility changes between TF 1.x and 2.x APIs.
• High · Outdated Keras with Known Vulnerabilities — requirements.txt. Keras==2.3.1 is outdated and no longer maintained as a standalone package. It contains potential security issues and is incompatible with modern TensorFlow versions. Keras is now integrated into TensorFlow. Fix: Remove standalone Keras dependency. Use tensorflow.keras from TensorFlow 2.x instead. Update all imports from 'keras' to 'tensorflow.keras'.
• High · Outdated Pillow with Known CVEs — requirements.txt. Pillow==8.1.2 is an older version with known security vulnerabilities including arbitrary code execution via malicious image files (CVE-2021-28957 and others). Current secure versions are 9.x and 10.x. Fix: Upgrade to Pillow>=10.0.0 (or at minimum 9.5.0). Test image loading functionality after upgrade.
• Medium · Outdated NumPy Version — requirements.txt. numpy==1.18.5 is outdated (released in 2020) and may have known security issues. Modern versions provide better security patches and performance. Fix: Upgrade to numpy>=1.24.0. Verify compatibility with other dependencies after upgrade.
• Medium · Outdated SciPy Version — requirements.txt. scipy==1.2.0 is severely outdated (released in 2019) and may contain unpatched vulnerabilities. Fix: Upgrade to scipy>=1.10.0. Test numerical computations to ensure consistency.
• Medium · Outdated OpenCV Version — requirements.txt. opencv_python==4.4.0.42 is outdated and may have known security vulnerabilities related to image processing. Fix: Upgrade to opencv-python>=4.8.0.74. Verify video processing pipelines work correctly after upgrade.
• Low · No Version Pinning Upper Bounds — requirements.txt. While dependencies have specific versions, there are no upper bounds defined (e.g., tensorflow==1.15.0 instead of tensorflow>=1.15.0,<2.0.0). This could lead to unexpected behavior if packages are reinstalled later. Fix: Use requirements-lock.txt with exact versions for reproducibility, and requirements.txt with version ranges for flexibility. Consider using pip-tools or Poetry for dependency management.
• Low · Potential Path Traversal in Data Loading — utilities/data_loader.py. File 'utilities/data_loader.py' is present but not analyzed. Data loaders commonly have path traversal vulnerabilities if file paths are not properly validated. Fix: Review data_loader.py to ensure: (1) File paths are validated and normalized, (2) No arbitrary directory traversal is possible, (3) Input paths are restricted to expected directories using os.path.realpath() and assertions.
• Low · Missing Security Documentation — Repository root. No security guidelines, SECURITY.md, or vulnerability disclosure policy is evident in the repository structure. Fix: Add a SECURITY.md file with vulnerability disclosure procedures and security best practices for users of this codebase.

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. Read in the suggested order before editing unfamiliar code. The reading-order list is computed from the actual import graph, not LLM guesses; reading bottom-up materially reduces wrong-edit risk.
3. 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.
4. Cite source on changes. When proposing an edit, cite the specific path/to/file.ext:Lstart-Lend you're reasoning about, the same way RepoPilot's own RAG cites code in https://repopilot.app/r/sjmoran/low-light-video-enhancement.

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 sjmoran/low-light-video-enhancement repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/sjmoran/low-light-video-enhancement.

What it runs against: a local clone of sjmoran/low-light-video-enhancement — 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 sjmoran/low-light-video-enhancement | Confirms the artifact applies here, not a fork | | 2 | License is still Other | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 1703 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of sjmoran/low-light-video-enhancement. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/sjmoran/low-light-video-enhancement.git
#   cd low-light-video-enhancement
#
# 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 sjmoran/low-light-video-enhancement and re-run."
  exit 2
fi

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

# 2. License matches what RepoPilot saw
(grep -qiE "^(Other)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"Other\"" package.json 2>/dev/null) \\
  && ok "license is Other" \\
  || miss "license drift — was Other at generation time"

# 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 "train_cyclegan_a2b.py" \\
  && ok "train_cyclegan_a2b.py" \\
  || miss "missing critical file: train_cyclegan_a2b.py"
test -f "train_cyclegan_b2c.py" \\
  && ok "train_cyclegan_b2c.py" \\
  || miss "missing critical file: train_cyclegan_b2c.py"
test -f "src/CycleGAN.py" \\
  && ok "src/CycleGAN.py" \\
  || miss "missing critical file: src/CycleGAN.py"
test -f "models/ICCV_architectures.py" \\
  && ok "models/ICCV_architectures.py" \\
  || miss "missing critical file: models/ICCV_architectures.py"
test -f "utilities/data_loader.py" \\
  && ok "utilities/data_loader.py" \\
  || miss "missing critical file: utilities/data_loader.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 1703 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~1673d)"
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/sjmoran/low-light-video-enhancement"
  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).

Computed from the actual import graph (no LLM). Read in this order to learn the codebase from the foundation up — each step builds on the previous ones.

1. utilities/instance_normalization.py — Foundation: doesn't import anything internally and is imported by 2 other files. Read first to learn the vocabulary.
2. utilities/data_loader.py — Foundation: imported by 1, no internal dependencies of its own.
3. src/train_cycleGAN.py — Built on the foundation; imported by 2 downstream files.
4. models/ICCV_architectures.py — Built on the foundation; imported by 1 downstream file.
5. src/CycleGAN.py — Layer 2 — application-level code that wires the lower layers together.
6. train_cyclegan_a2b.py — Layer 3 — application-level code that wires the lower layers together.

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