rsdiff 0.1.0__py3-none-any.whl

rsdiff/datasets/rsicd.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import random
+from pathlib import Path
+
+import pandas as pd
+from PIL import Image
+
+from rsdiff.datasets.base import RSDataset, Sample
+
+
+class RSICD(RSDataset):
+    """Remote Sensing Image Captioning Dataset.
+
+    Expects the standard layout::
+
+        <root>/RSICD_images/*.jpg
+        <root>/dataset_rsicd.csv
+
+    The CSV has columns ``filename, split, imgid, sent1..sent5, label``.
+    A random one of the five captions is returned per ``__getitem__`` call
+    by default to act as caption-level augmentation; set ``caption_idx``
+    to a value in ``0..4`` to pin a specific column.
+    """
+
+    name = "rsicd"
+    splits = ("train", "val", "test")
+
+    def __init__(
+        self,
+        root: str | Path,
+        split: str = "train",
+        transform=None,
+        caption_idx: int | None = None,
+        images_subdir: str = "RSICD_images",
+        csv_name: str = "dataset_rsicd.csv",
+    ) -> None:
+        super().__init__(root, split=split, transform=transform)
+        self.caption_idx = caption_idx
+        self.images_dir = self.root / images_subdir
+        csv_path = self.root / csv_name
+        if not csv_path.is_file():
+            raise FileNotFoundError(f"RSICD CSV not found at {csv_path}")
+        df = pd.read_csv(csv_path)
+        self.df = df[df["split"] == split].reset_index(drop=True)
+        self._caption_cols = [f"sent{i}" for i in range(1, 6)]
+
+    def __len__(self) -> int:
+        return len(self.df)
+
+    def __getitem__(self, idx: int) -> Sample:
+        row = self.df.iloc[idx]
+        img = Image.open(self.images_dir / row["filename"]).convert("RGB")
+        if self.transform is not None:
+            img = self.transform(img)
+
+        if self.caption_idx is None:
+            caption = row[random.choice(self._caption_cols)]
+        else:
+            caption = row[self._caption_cols[self.caption_idx]]
+
+        return Sample(
+            image=img,
+            caption=str(caption),
+            label=str(row.get("label", "")) or None,
+            meta={"filename": row["filename"], "imgid": int(row["imgid"])},
+        )
+
+    @property
+    def classes(self) -> list[str]:
+        return sorted(self.df["label"].dropna().unique().tolist())
+
+
+def sample_captions(
+    root: str | Path,
+    split: str = "test",
+    n: int | None = None,
+    seed: int = 17,
+    csv_name: str = "dataset_rsicd.csv",
+) -> list[str]:
+    """Pick ``n`` first captions (``sent1``) from ``split``, shuffled with ``seed``.
+
+    ``n=None`` returns every row of the split. With ``seed=17``, the full test split and a
+    CSV built by ``scripts/build_rsicd_csv.py --split-csv``, this returns exactly the
+    captions of the published 1,093-image evaluation bundle.
+    """
+    df = pd.read_csv(Path(root) / csv_name)
+    df = df[df["split"] == split].reset_index(drop=True)
+    if df.empty:
+        raise ValueError(f"no rows for split={split!r} in {Path(root) / csv_name}")
+    k = len(df) if n is None else min(n, len(df))
+    return df.sample(n=k, random_state=seed)["sent1"].astype(str).tolist()

rsdiff/eval/__init__.py

@@ -0,0 +1,11 @@
+"""Evaluation metrics for generated remote-sensing imagery.
+
+- ``fid``: Fréchet Inception Distance (torchmetrics, Inception feature 2048 by default);
+  the metric behind the published FID 65.70.
+- ``clip_score``: caption-image CLIP similarity with a shuffled-caption baseline.
+"""
+
+from rsdiff.eval.clip import CLIPResult, clip_score
+from rsdiff.eval.fid import FIDResult, fid
+
+__all__ = ["CLIPResult", "FIDResult", "clip_score", "fid"]

rsdiff/eval/clip.py

@@ -0,0 +1,90 @@
+"""CLIP score of a generation bundle, with a shuffled-caption null baseline.
+
+The score is the mean cosine similarity between each image and its caption under OpenAI
+CLIP ViT-B/32. The baseline pairs every image with another image's caption (fixed shuffle,
+seed 17); ``delta`` is how much the real pairing beats chance. Published release values:
+0.278 vs 0.232 (delta +0.046) on the 1,093-image RSICD test bundle.
+"""
+
+from __future__ import annotations
+
+import random
+from dataclasses import dataclass
+from pathlib import Path
+
+import torch
+from PIL import Image
+
+from rsdiff.eval.fid import _auto_device
+
+DEFAULT_CLIP_MODEL = "openai/clip-vit-base-patch32"
+
+
+@dataclass
+class CLIPResult:
+    clip_score: float
+    clip_score_std: float
+    clip_score_shuffled: float
+    delta: float
+    n: int
+    model: str
+
+
+def bundle_pairs(gen_dir: str | Path) -> tuple[list[str], list[Path]]:
+    """Return the captions and PNGs of a bundle written by ``rsdiff sample``.
+
+    Captions come from ``captions.txt``; PNGs are paired with them in sorted file order.
+    """
+    gen_dir = Path(gen_dir)
+    captions = (gen_dir / "captions.txt").read_text(encoding="utf-8").splitlines()
+    pngs = sorted(p for p in gen_dir.glob("*.png") if p.name != "_grid.png")
+    if len(pngs) != len(captions):
+        raise ValueError(f"{len(pngs)} PNGs but {len(captions)} captions in {gen_dir}")
+    return captions, pngs
+
+
+def clip_score(
+    gen_dir: str | Path,
+    model_id: str = DEFAULT_CLIP_MODEL,
+    shuffle_seed: int = 17,
+    device: str | None = None,
+) -> CLIPResult:
+    from transformers import CLIPModel, CLIPProcessor
+
+    captions, pngs = bundle_pairs(gen_dir)
+    device = device or _auto_device()
+    model = CLIPModel.from_pretrained(model_id, use_safetensors=True).to(device).eval()
+    proc = CLIPProcessor.from_pretrained(model_id)
+
+    with torch.no_grad():
+        text = []
+        for i in range(0, len(captions), 64):
+            tk = proc(
+                text=captions[i : i + 64], return_tensors="pt", padding=True, truncation=True
+            ).to(device)
+            text.append(model.get_text_features(**tk).cpu())
+        image = []
+        for i in range(0, len(pngs), 32):
+            imgs = [Image.open(p).convert("RGB") for p in pngs[i : i + 32]]
+            image.append(
+                model.get_image_features(**proc(images=imgs, return_tensors="pt").to(device)).cpu()
+            )
+
+    te = torch.cat(text)
+    te = te / te.norm(dim=-1, keepdim=True)
+    ie = torch.cat(image)
+    ie = ie / ie.norm(dim=-1, keepdim=True)
+    sim = (te * ie).sum(-1)
+
+    order = list(range(len(captions)))
+    random.Random(shuffle_seed).shuffle(order)
+    sim_shuffled = (te[order] * ie).sum(-1)
+
+    return CLIPResult(
+        clip_score=sim.mean().item(),
+        clip_score_std=sim.std().item(),
+        clip_score_shuffled=sim_shuffled.mean().item(),
+        delta=(sim.mean() - sim_shuffled.mean()).item(),
+        n=len(pngs),
+        model=model_id,
+    )

rsdiff/eval/fid.py

@@ -0,0 +1,125 @@
+"""Fréchet Inception Distance for generated RS imagery.
+
+torchmetrics' ``FrechetInceptionDistance`` (InceptionV3 backbone). Stage-agnostic:
+point ``gen_dir`` at whatever the model produced — LR 128² grids, SR 256² grids,
+or full-cascade 256² — and ``real_*`` at the matching RSICD split. Both sides are
+resized to ``image_size`` before the metric (Inception rescales to 299 internally),
+so keep ``image_size`` equal to the stage you are scoring (128 for LR, 256 for SR /
+cascade) and compare only against numbers computed the same way.
+
+The thesis FID snippet (commented out in the legacy non-cascade DDPM script) used
+``feature=64``; standard, paper-comparable FID is ``feature=2048``. Both are exposed
+so we can reproduce the thesis number *and* report a comparable one.
+
+Note: FID is biased for small samples. Use the full test split (~1093 generations),
+not a 16-image grid, for a number worth quoting.
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+
+import pandas as pd
+import torch
+from PIL import Image
+from tqdm import tqdm
+
+_IMG_EXTS = {".png", ".jpg", ".jpeg", ".bmp", ".tif", ".tiff", ".webp"}
+
+
+def _auto_device() -> str:
+    # Not MPS: torchmetrics keeps FID statistics in float64, which MPS does not support.
+    return "cuda" if torch.cuda.is_available() else "cpu"
+
+
+@dataclass
+class FIDResult:
+    fid: float
+    feature: int
+    image_size: int
+    n_real: int
+    n_gen: int
+
+
+def _load_uint8(path: Path, size: int) -> torch.Tensor:
+    """Load one image as a CxHxW uint8 tensor at (size, size)."""
+    img = Image.open(path).convert("RGB").resize((size, size), Image.BICUBIC)
+    t = torch.frombuffer(img.tobytes(), dtype=torch.uint8)
+    return t.view(size, size, 3).permute(2, 0, 1).contiguous()
+
+
+def _real_paths(real_csv: Path | None, real_dir: Path, split: str) -> list[Path]:
+    if real_csv is not None:
+        df = pd.read_csv(real_csv)
+        df = df[df["split"] == split].reset_index(drop=True)
+        if df.empty:
+            raise ValueError(f"No rows for split={split!r} in {real_csv}")
+        return [real_dir / fn for fn in df["filename"]]
+    return [p for p in sorted(real_dir.iterdir()) if p.suffix.lower() in _IMG_EXTS]
+
+
+def _gen_paths(gen_dir: Path) -> list[Path]:
+    return sorted(p for p in gen_dir.rglob("*") if p.suffix.lower() in _IMG_EXTS)
+
+
+def fid(
+    gen_dir: str | Path,
+    real_csv: str | Path | None = None,
+    real_dir: str | Path | None = None,
+    split: str = "test",
+    feature: int = 2048,
+    image_size: int = 256,
+    batch_size: int = 32,
+    max_n: int | None = None,
+    device: str | None = None,
+) -> FIDResult:
+    from torchmetrics.image.fid import FrechetInceptionDistance
+
+    device = device or _auto_device()
+    gen_dir = Path(gen_dir)
+    if real_dir is None and real_csv is None:
+        raise ValueError("provide real_csv (+ real_dir) or real_dir")
+    real_dir = Path(real_dir) if real_dir is not None else None
+    real_csv = Path(real_csv) if real_csv is not None else None
+    if real_csv is not None and real_dir is None:
+        raise ValueError("real_csv needs real_dir (image root for its filenames)")
+
+    real = _real_paths(real_csv, real_dir, split)
+    gen = _gen_paths(gen_dir)
+    if max_n is not None:
+        real, gen = real[:max_n], gen[:max_n]
+    if not real or not gen:
+        raise ValueError(f"empty set (real={len(real)}, gen={len(gen)})")
+
+    metric = FrechetInceptionDistance(feature=feature, normalize=False).to(device)
+
+    def _feed(paths: list[Path], real_flag: bool, desc: str) -> int:
+        buf: list[torch.Tensor] = []
+        n = 0
+        for p in tqdm(paths, desc=desc):
+            if not p.exists():
+                continue
+            try:
+                buf.append(_load_uint8(p, image_size))
+            except Exception:
+                continue
+            if len(buf) >= batch_size:
+                metric.update(torch.stack(buf).to(device), real=real_flag)
+                n += len(buf)
+                buf.clear()
+        if buf:
+            metric.update(torch.stack(buf).to(device), real=real_flag)
+            n += len(buf)
+        return n
+
+    n_real = _feed(real, True, "fid/real")
+    n_gen = _feed(gen, False, "fid/gen")
+
+    return FIDResult(
+        fid=float(metric.compute().item()),
+        feature=feature,
+        image_size=image_size,
+        n_real=n_real,
+        n_gen=n_gen,
+    )

rsdiff-0.1.0.dist-info/METADATA

@@ -0,0 +1,245 @@
+Metadata-Version: 2.5
+Name: rsdiff
+Version: 0.1.0
+Summary: Text-to-satellite-image diffusion: the RSDiff cascade (NCAA 2024), released weights, and its FID/CLIP evaluation.
+Project-URL: Homepage, https://github.com/asebaq/rsdiff
+Project-URL: Documentation, https://asebaq.github.io/rsdiff
+Project-URL: Issues, https://github.com/asebaq/rsdiff/issues
+Project-URL: Changelog, https://github.com/asebaq/rsdiff/blob/main/CHANGELOG.md
+Project-URL: Paper, https://doi.org/10.1007/s00521-024-10363-3
+Project-URL: Weights, https://huggingface.co/asebaq/rsdiff-sr-cascade-ep650
+Author-email: Ahmad Sebaq <ahmad.sebaq@gmail.com>
+License-Expression: Apache-2.0
+License-File: LICENSE
+License-File: NOTICE
+Keywords: diffusion,imagen,remote-sensing,rsicd,satellite,text-to-image
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Scientific/Engineering :: Image Processing
+Requires-Python: >=3.10
+Requires-Dist: huggingface-hub>=0.25
+Requires-Dist: imagen-pytorch==2.1.0
+Requires-Dist: numpy>=1.26
+Requires-Dist: omegaconf>=2.3
+Requires-Dist: pandas>=2.2
+Requires-Dist: pillow>=10.4
+Requires-Dist: torch>=2.4
+Requires-Dist: torchvision>=0.19
+Requires-Dist: tqdm>=4.66
+Requires-Dist: transformers<5,>=4.44
+Provides-Extra: eval
+Requires-Dist: torchmetrics[image]>=1.4; extra == 'eval'
+Description-Content-Type: text/markdown
+
+<h1 align="center">
+  <a href="https://github.com/asebaq/rsdiff">
+    <picture>
+      <source media="(prefers-color-scheme: dark)" srcset="https://raw.githubusercontent.com/asebaq/rsdiff/main/docs/assets/cover_dark.svg">
+      <img alt="rsdiff" src="https://raw.githubusercontent.com/asebaq/rsdiff/main/docs/assets/cover_light.svg" width="640">
+    </picture>
+  </a>
+</h1>
+
+<p align="center">
+  <a href="https://pypi.org/project/rsdiff/"><img alt="PyPI" src="https://img.shields.io/pypi/v/rsdiff?color=1D4ED8"></a>
+  <a href="https://pypi.org/project/rsdiff/"><img alt="Python" src="https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fasebaq%2Frsdiff%2Fmain%2Fpyproject.toml"></a>
+  <a href="https://github.com/asebaq/rsdiff/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/asebaq/rsdiff/actions/workflows/ci.yml/badge.svg"></a>
+  <a href="https://github.com/asebaq/rsdiff/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/github/license/asebaq/rsdiff"></a>
+  <a href="https://doi.org/10.1007/s00521-024-10363-3"><img alt="DOI" src="https://img.shields.io/badge/DOI-10.1007%2Fs00521--024--10363--3-blue"></a>
+  <a href="https://huggingface.co/asebaq/rsdiff-sr-cascade-ep650"><img alt="Hugging Face model" src="https://img.shields.io/badge/Hugging%20Face-rsdiff--sr--cascade--ep650-yellow"></a>
+</p>
+
+<p align="center">
+  <a href="#install"><strong>Install</strong></a> &middot;
+  <a href="#use"><strong>Use</strong></a> &middot;
+  <a href="#results"><strong>Results</strong></a> &middot;
+  <a href="#how-it-works"><strong>How it works</strong></a> &middot;
+  <a href="#limitations"><strong>Limitations</strong></a> &middot;
+  <a href="#training"><strong>Training</strong></a> &middot;
+  <a href="#roadmap"><strong>Roadmap</strong></a> &middot;
+  <a href="#citation"><strong>Citation</strong></a>
+</p>
+
+**Text-to-satellite-image diffusion, packaged.** rsdiff is the reference implementation
+of RSDiff ([Neural Computing and Applications, 2024](https://doi.org/10.1007/s00521-024-10363-3)):
+a T5-conditioned, Imagen-style cascaded diffusion model that turns a caption such as
+"many buildings and green trees are around a playground ." into a 256x256 synthetic
+remote-sensing image. One command downloads the released RSICD-trained checkpoint,
+verifies it, and samples; a second scores the result with the same FID and CLIP-score
+protocol used for the published numbers (FID 65.70, CLIP-score 0.278 on the full
+RSICD test split).
+
+Every image rsdiff produces is synthetic. It is not an observation or a prediction of
+any real place, and each PNG says so in its metadata.
+
+<p align="center">
+  <img src="https://raw.githubusercontent.com/asebaq/rsdiff/main/docs/figures/sample_montage.png" width="780" alt="Synthetic 256x256 samples generated from RSICD test captions">
+</p>
+
+## Install
+
+```bash
+pip install rsdiff            # sampling + CLIP-score
+pip install "rsdiff[eval]"    # adds torchmetrics for FID
+```
+
+Python 3.10+. Sampling runs on CUDA when available and otherwise on CPU. Apple MPS is
+not supported: imagen-pytorch 2.1.0 and the torchmetrics FID both use float64.
+
+## Use
+
+Generate images from your own captions. The first run downloads the released checkpoint
+(1.9 GB, pinned Hugging Face revision) and verifies its SHA-256:
+
+```bash
+rsdiff sample --prompt "many buildings and green trees are around a playground ." -n 4 --out-dir generated
+```
+
+This writes 256x256 PNGs and a `captions.txt` to `generated/`. `--prompt` can be
+repeated. Each PNG carries `Software`, `Description` (a synthetic-content notice), and
+`Prompt` text chunks.
+
+Or draw captions from RSICD (first caption, `sent1`, shuffled with `--seed`, default 17):
+
+```bash
+rsdiff sample --rsicd data/RSICD_optimal --split test -n 16 --out-dir generated
+```
+
+Useful options: `--cond-scale` (default 5), `--batch-size` (default 2), `--lr-only`
+(stop at the 128x128 base stage), `--cpu`, `--config rsdiff1.5|rsdiff1|path.yaml`, and
+`--checkpoint PATH` (required for non-default configs). An interrupted run resumes:
+batches whose PNGs already exist are skipped.
+
+Score a generated directory against the RSICD test split:
+
+```bash
+rsdiff eval fid generated --rsicd data/RSICD_optimal    # --feature 2048 --size 256 by default
+rsdiff eval clip generated                             # clip_score, clip_score_shuffled, delta
+```
+
+Both print JSON. The same pieces are available from Python:
+
+```python
+from rsdiff.cascade import download_release, generate, load_cascade
+from rsdiff.config import load_preset
+from rsdiff.eval import clip_score
+
+cfg = load_preset("rsdiff1.5")
+trainer = load_cascade(cfg, download_release())
+paths = generate(trainer.sample, ["a river runs through the green farmland ."], "generated")
+print(clip_score("generated"))
+```
+
+`rsdiff.datasets.rsicd.sample_captions` reproduces the CLI's RSICD caption draw, and
+`rsdiff.eval.fid` computes FID.
+
+## Results
+
+Released checkpoint, full RSICD test split (N=1,093), cascade output at 256x256,
+`cond_scale=5`:
+
+| Metric | Value |
+| --- | --- |
+| FID (torchmetrics Inception, feature 2048, both sides at 256) | **65.70** |
+| CLIP-score (OpenAI CLIP ViT-B/32) | **0.278** |
+| CLIP-score, shuffled-caption baseline | 0.232 |
+| Parameters (base UNet 27.2 M + SR UNet 92.7 M) | 119.9 M[^params] |
+
+[^params]: 119.9 M counts the two standalone UNets, as in the paper and model card.
+    Loaded inside the cascade, the SR UNet gains low-resolution conditioning layers
+    (105.0 M), so the cascade holds 132.2 M trainable parameters, plus the frozen T5-base
+    text encoder.
+
+The CLIP-score sits 0.046 above the shuffled-caption baseline: the images follow their
+captions, not just the RSICD domain.
+
+| Curve | Figure |
+| --- | --- |
+| SR FID versus epoch (ep150 to ep1000) | [`docs/figures/sr_fid_curve.png`](docs/figures/sr_fid_curve.png) |
+| CFG `cond_scale` sweep on the selected SR milestone | [`docs/figures/cfg_sweep.png`](docs/figures/cfg_sweep.png) |
+| LR base FID versus epoch | [`docs/figures/lr_fid_curve.png`](docs/figures/lr_fid_curve.png) |
+
+The numbers behind every figure are committed in [`results/`](results/). Methodology and
+discussion: [`docs/REPORT.md`](docs/REPORT.md). Model card:
+[`docs/model_card.md`](docs/model_card.md).
+
+## How it works
+
+1. A frozen **T5-base** encoder turns the caption into token embeddings.
+2. A **128x128 base UNet** denoises from noise over 1,000 DDPM steps, cross-attending to
+   the text.
+3. A **256x256 super-resolution UNet** denoises again, conditioned on the text and the
+   upsampled base image.
+
+Both stages use classifier-free guidance (trained with 10% caption dropout) with a shared
+`cond_scale`; 5 is the value selected by the CFG sweep and used for every headline
+number. Sampling uses the EMA weights of the merged epoch-650 checkpoint. The presets
+ship inside the package: [`rsdiff1.5`](src/rsdiff/configs/rsdiff1.5.yaml) (released) and
+[`rsdiff1`](src/rsdiff/configs/rsdiff1.yaml) (the 723 M paper configuration; weights not
+released).
+
+## Limitations
+
+- **Synthetic only.** Outputs are plausible-looking imagery, not observed or predicted
+  geography. Do not use them as evidence about a real location.
+- **RSICD domain.** The model was trained on the 30 RSICD scene types and their short,
+  lowercase captions. Prompts unlike those captions have not been evaluated.
+- **256 px.** The cascade stops at 256x256.
+- **No Apple MPS.** float64 operations in imagen-pytorch 2.1.0 and torchmetrics FID are
+  not supported on MPS.
+- **CPU sampling is slow.** 2,000 denoising steps per image took about an hour on an
+  Apple-silicon CPU; use a CUDA GPU for more than a handful of images.
+- **Weights not commercially cleared.** RSICD's commercial terms are unresolved; see
+  [`docs/LICENSE_AUDIT.md`](docs/LICENSE_AUDIT.md).
+
+## Training
+
+Training still runs through the frozen reference implementation in [`ddpm/`](ddpm/):
+
+```bash
+bash ddpm/scripts/run_training_local.sh   # stage 1: 128x128 base UNet
+bash ddpm/scripts/run_sr.sh               # stage 2: 256x256 SR UNet on the frozen base
+```
+
+[`docs/reproducibility.md`](docs/reproducibility.md) is the complete runbook: environment,
+dataset preparation, training, milestone sweeps, sampling the 1,093-image bundle, and
+scoring.
+
+## Roadmap
+
+1. **Reproduce with the package.** Regenerate the 1,093-image bundle with `rsdiff sample`
+   and match the published FID and CLIP-score; then delete `ddpm/`.
+2. **Commercial relevance.** Test whether synthetic augmentation improves a downstream
+   model on an untouched real-data test set.
+
+Details and acceptance criteria: [`docs/PLAN.md`](docs/PLAN.md).
+
+## Citation
+
+```bibtex
+@article{sebaq2024rsdiff,
+  title   = {RSDiff: remote sensing image generation from text using diffusion model},
+  author  = {Sebaq, Ahmad and ElHelw, Mohamed},
+  journal = {Neural Computing and Applications},
+  volume  = {36},
+  number  = {36},
+  pages   = {23103--23111},
+  year    = {2024},
+  doi     = {10.1007/s00521-024-10363-3}
+}
+```
+
+## License
+
+Code: Apache-2.0, see [`LICENSE`](LICENSE) and [`NOTICE`](NOTICE). The released weights
+were trained on RSICD, whose commercial terms are unresolved; dataset, dependency, and
+derived-weight rights are tracked in [`docs/LICENSE_AUDIT.md`](docs/LICENSE_AUDIT.md).
+Built on [`lucidrains/imagen-pytorch`](https://github.com/lucidrains/imagen-pytorch);
+developed at the Center for Informatics Science, Nile University.

rsdiff-0.1.0.dist-info/RECORD

@@ -0,0 +1,18 @@
+rsdiff/__init__.py,sha256=dFKNtf5sLNLYerXv1U5_rCqkv47ZAgEild_lbXT1JCE,72
+rsdiff/cascade.py,sha256=jLtxb3uFCLBR3xlplgWXwnGL4LK6ufgkbfsPJxCprbY,6905
+rsdiff/cli.py,sha256=GWWLmDCaTF7T7i346VV_jaIQZUSFmPX2wlPIud07AW4,5335
+rsdiff/config.py,sha256=aTCDO3WBcYbHxEVeFyh1NvNKBT_ieegI3igBZnm7u3M,3272
+rsdiff/configs/rsdiff1.5.yaml,sha256=iE88GumtvABPMv8T6B8JRM53GHwA7L7XyvKdDfWCWYM,1476
+rsdiff/configs/rsdiff1.yaml,sha256=sQIz77iWh60CeYhttRJpneM0HEpPCbCXHQF91sfUUBk,1986
+rsdiff/datasets/__init__.py,sha256=iWek0miCKlsqryty69wNtDB2H4HonY2I9G6HgYU9gYA,395
+rsdiff/datasets/base.py,sha256=EnY4p3bBxHOCYOUT_zjzKbkiW3_rxa7hBRV71XYIWa4,1161
+rsdiff/datasets/rsicd.py,sha256=bkucy-28f9F-FgaNucejywayd1oIoZTln9pFjk9OCw4,3053
+rsdiff/eval/__init__.py,sha256=w_3fuw-_b0uinrfxfb8LR8TT1BoeTvlvxGJ5B1hUxbs,438
+rsdiff/eval/clip.py,sha256=5rGKZy-O2EgvCNiypu7O9V5ECg--Wyl7oKGbYyo9feY,2969
+rsdiff/eval/fid.py,sha256=Vfdc6NIgu6nyM0ZLF4EjG84ST23LMNmag-ebYS3Z8SQ,4401
+rsdiff-0.1.0.dist-info/METADATA,sha256=GZBcFbvzqYdf_TyMeuiYPtF-m41fQNJlqv5YfipIM5s,11163
+rsdiff-0.1.0.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+rsdiff-0.1.0.dist-info/entry_points.txt,sha256=d0In_rBx8UOk3W4TiPNvkl1XIXaGMC7d9SoOlgx0sig,43
+rsdiff-0.1.0.dist-info/licenses/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+rsdiff-0.1.0.dist-info/licenses/NOTICE,sha256=G_IlLEooLyCpILDADhExxse-DRNF6Nq3YbSzk2BGgwQ,1192
+rsdiff-0.1.0.dist-info/RECORD,,

rsdiff-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.4
+Root-Is-Purelib: true
+Tag: py3-none-any

rsdiff-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+rsdiff = rsdiff.cli:main