Upload 7 files

README.md

@@ -1,3 +1,214 @@
 ---
 license: mit
+library_name: pytorch
+tags:
+  - computer-vision
+  - affective-computing
+  - neuroscience
+  - image-regression
+  - vgg16
+  - pavlovian-conditioning
+  - valence-prediction
 ---
+
+# Visual-Valence Model (VCA)
+
+> A deep neural network model of associative emotional (Pavlovian fear) learning.
+
+Companion model repository for **["Associative Emotional Learning in Convolutional Neural Networks"](https://arxiv.org/abs/2607.19327)**
+(Leem, Keil, Ding & Fang; *Neural Computation*, in press).
+
+- 📄 Paper: https://arxiv.org/abs/2607.19327
+- 💻 Code: https://github.com/lab-smile/FearConditioningAI
+
+> **Note:** This model is a research artifact for computational/cognitive neuroscience, released to
+> reproduce and extend the paper's findings. It is **not** a general-purpose sentiment/emotion API and
+> is not validated for clinical, diagnostic, or production affective-computing use.
+
+---
+
+## Model description
+
+The Visual-Valence Model predicts the affective **valence** of a visual scene (1 = extreme displeasure,
+9 = extreme pleasure) and reproduces hallmarks of Pavlovian (fear) conditioning when a novel, initially
+neutral stimulus is repeatedly paired with an emotionally-charged one.
+
+The architecture (`Visual_Cortex_Amygdala` in [`models/VGG_Model.py`](https://github.com/lab-smile/FearConditioningAI/blob/main/models/VGG_Model.py))
+has three components, loosely modeling the primate visual/affective pathway:
+
+| Component | Role | Implementation |
+|---|---|---|
+| **Visual Cortex module** ("High Road") | Ventral visual stream | VGG-16 (Simonyan & Zisserman, 2015), ImageNet-pretrained, **frozen** |
+| **Shortcut Pathway** ("Middle Road") | Fast, low-resolution route from early vision to affect circuitry | Multi-scale pooling of VGG-16's early layers (layer index 10), combined via an Efficient Channel Attention (ECA) module (Wang et al., 2020) |
+| **Valence Module** | Combines both pathways into a scalar valence judgment | Two fully-connected layers (amygdala LA/CE-nuclei- and OFC-inspired) + one sigmoid output unit |
+
+The High Road output (4096-d) and Middle Road output (512-d) are concatenated (4608-d) and passed through
+the Valence Module's fully connected layers to a single sigmoid unit, which is linearly rescaled from
+`[0, 1]` to the `[1, 9]` IAPS valence scale at evaluation time.
+
+### Five checkpoints, one training pipeline
+
+This repository hosts every checkpoint along the training pipeline described in the
+[GitHub README](https://github.com/lab-smile/FearConditioningAI#training) — same architecture
+(`Visual_Cortex_Amygdala`) throughout, so any of them can be loaded with the same code:
+
+| File | Stage | Description | Val. R | Val. MSE |
+|---|---|---|---|---|
+| `vca_ckvideo_batch128_lr2e-5_epoch20.pth` | 0 | Trained from scratch on the Cowen & Keltner Videoframe dataset | 0.386 | 0.043 |
+| `vca_IAPS_batch10_lr2e-4_epoch23.pth` | 1 | Fine-tuned on full-size IAPS images | 0.538 | 0.192 |
+| `base_model_vca_IAPS_quadrant.pth` | 2 | Fine-tuned to the quadrant-cropped input layout — **pre-conditioning**: has learned to decode valence from natural scenes (the US) but has never seen the conditioned stimulus (CS, a Gabor patch) | see paper | see paper |
+| `base_model_conditioned_orientation_epoch1.pth` | 3, epoch 1 | First epoch of Pavlovian conditioning (CS+ Gabor patch paired with pleasant/unpleasant IAPS US); early/under-trained, kept for provenance | 0.660 | 0.466 |
+| `base_model_conditioned_orientation_epoch100.pth` | 3, epoch 100 | **Post-conditioning (final)** — used throughout the paper's conditioning/generalization/representational-alignment analyses | see paper | see paper |
+
+Stage 0/1 metrics are Pearson R / MSE on their respective held-out validation sets (read from each
+checkpoint's own logged `best_per` / `best_loss`). Stage 2 and the final Stage 3 (epoch 100) numbers are
+intentionally not restated here — see the paper for the definitive, fully-trained results.
+
+Comparing the pre- (Stage 2) and post-conditioning (Stage 3, epoch 100) checkpoints' responses to the CS
+alone is what reveals the learned CS→valence association (and, at the representation level, the
+increasing CS/US alignment reported in the paper).
+
+---
+
+## Intended use
+
+- Reproducing the paper's Pavlovian-conditioning experiments and figures.
+- Extending the model to new conditioning paradigms, stimulus sets, or ablations (e.g. the
+  attention-free variant, `Visual_Cortex_Amygdala_wo_Attention`) for **research purposes**.
+- Studying how a two-pathway (ventral-stream + shortcut) architecture with attention reproduces
+  behavioral/representational signatures of associative emotional learning.
+- Feature extraction / representational analysis (see `Channel_Activity_Extraction.py`,
+  `Manifold_Visualization.py`, `SVM_Analysis_*.py` in the GitHub repo) for downstream neuroscience analyses.
+
+**Out of scope:** general-purpose sentiment analysis, affect recognition on non-IAPS-like natural images,
+clinical/diagnostic use, or any decision-making about real individuals' emotional states.
+
+---
+
+## Limitations
+
+- **Frozen ImageNet backbone.** The High Road (VGG-16) is never fine-tuned, so the model inherits
+  ImageNet's visual biases; only the shortcut pathway and valence module are trained on affective data.
+- **Narrow, licensed training data.** IAPS is a relatively small, curated stimulus set under a
+  data-use/confidentiality agreement (not redistributed with the code or this checkpoint); the model's
+  generalization to naturalistic, in-the-wild imagery is untested.
+- **Two-alternative conditioning paradigm.** The conditioning stage pairs exactly two Gabor orientations
+  (45°, 135°) with unpleasant/pleasant IAPS images; behavior on other CS types has not been evaluated.
+- **Not validated against individual human subjects.** Comparisons to human data in the paper are at the
+  group/aggregate level; the model is not a predictive model of any specific person's affective response.
+- **Single scalar output.** The model predicts only valence (pleasant ↔ unpleasant), not arousal or
+  discrete emotion categories.
+
+---
+
+## Evaluation metrics
+
+Model quality is reported using:
+
+- **Pearson correlation (R / R²)** between predicted and ground-truth (SAM-rated) valence, computed by
+  `reg_eval_model` / `cond_eval_model` in [`utils.py`](https://github.com/lab-smile/FearConditioningAI/blob/main/utils.py).
+- **Mean-squared error (MSE)** between predicted and ground-truth valence (rescaled to the 1–9 scale).
+- Post-conditioning, generalization and CS/US **representational alignment** (single-unit tuning and
+  population-level RSA/t-SNE, via `Channel_Activity_Extraction.py`, `Manifold_Visualization.py`,
+  `SVM_Analysis_Emotion.py`, `SVM_Analysis_Before_After.py`) are used to assess whether conditioning
+  reproduces human associative-learning signatures.
+
+The full quantitative results (per-stage R/MSE, generalization curves, and alignment statistics) are
+reported in the paper's tables/figures — see https://arxiv.org/abs/2607.19327. The Stage 0/1 R and MSE
+values in the checkpoint table above are real, logged validation numbers for those checkpoints; the
+Stage 3/epoch-1 numbers are a very early, under-trained snapshot and are **not** representative of the
+final, fully-conditioned (epoch 100) model — included only for provenance, not as a reported result.
+
+---
+
+## Training dataset
+
+Training proceeds in stages, each building on the previous stage's checkpoint (see the GitHub README's
+[Training](https://github.com/lab-smile/FearConditioningAI#training) section for exact commands):
+
+| Stage | Dataset | Purpose |
+|---|---|---|
+| 0 | Cowen & Keltner (2017) Videoframe dataset (2,185 emotion-eliciting video clips, one frame sampled every 10th frame) | Pretrain valence regression from scratch on natural scenes |
+| 1 | International Affective Picture System (IAPS; Bradley & Lang, 1994/2007), full-size images, 8:1:1 train/val/test split | Adapt to the US stimuli used in conditioning |
+| 2 | IAPS, quadrant-cropped layout | Fine-tune to the spatial layout used during conditioning |
+| 3 | IAPS (US, in the 4th quadrant) × Gabor patches (CS, in the 2nd quadrant; 45°/135° orientation, varying spatial frequency/contrast, generated via `Gabor4Seowung.m`) | Pavlovian conditioning: pair CS+ with pleasant/unpleasant US |
+
+Labels are human valence ratings on a 1–9 scale (Self-Assessment Manikin; Bradley & Lang, 1994).
+**The IAPS images themselves are not redistributed** with the code or this model repository due to a
+data-use/confidentiality agreement — obtain access to IAPS independently to reproduce training from
+scratch. The Gabor-patch CS stimuli are procedurally generated and have no such restriction.
+
+Note the input layout differs by stage: Stage 0/1 checkpoints expect a full-frame natural image
+(resize + normalize only), while Stage 2/3 checkpoints expect the quadrant-cropped layout (see
+[Data preprocessing](https://github.com/lab-smile/FearConditioningAI#data-preprocessing) in the GitHub
+README) — feeding a full-frame image to a Stage 2/3 checkpoint (or vice versa) will not reproduce the
+reported behavior.
+
+---
+
+## How to use
+
+This is a plain PyTorch checkpoint (not a `transformers` model), so inference requires the model class
+definition from the companion GitHub repository. See [`inference_example.py`](inference_example.py) in
+this repository for a complete, runnable example. In short:
+
+```bash
+git clone https://github.com/lab-smile/FearConditioningAI.git
+cd FearConditioningAI
+pip install -r requirements.txt   # or: conda env create -f environment-<platform>.yml
+```
+
+```python
+import torch
+from huggingface_hub import hf_hub_download
+from models.VGG_Model import Visual_Cortex_Amygdala
+
+repo_id = "smilelab/visual-valence-model"
+# swap in any filename from the checkpoint table above, e.g. "vca_ckvideo_batch128_lr2e-5_epoch20.pth"
+ckpt_path = hf_hub_download(repo_id=repo_id, filename="base_model_conditioned_orientation_epoch100.pth")
+
+model = Visual_Cortex_Amygdala()
+checkpoint = torch.load(ckpt_path, map_location="cpu", weights_only=False)
+model.load_state_dict(checkpoint["state_dict"], strict=False)
+model.eval()
+```
+
+See `inference_example.py` for image preprocessing (resize/normalize + quadrant placement of the CS/US)
+and how to rescale the model's sigmoid output back to the 1–9 valence scale.
+
+---
+
+## Citation
+
+If you use this model, please cite the paper:
+
+```bibtex
+@article{leem2026associative,
+  title   = {Associative Emotional Learning in Convolutional Neural Networks},
+  author  = {Leem, Seowung and Keil, Andreas and Ding, Mingzhou and Fang, Ruogu},
+  journal = {Neural Computation},
+  year    = {2026},
+  note    = {in press},
+  eprint  = {2607.19327},
+  archivePrefix = {arXiv},
+  url     = {https://arxiv.org/abs/2607.19327}
+}
+```
+
+Please also cite the datasets and methods this model builds on (IAPS, Cowen & Keltner Videoframe, SAM,
+VGG-16, ImageNet, ECA-Net, Rescorla-Wagner) — full references in the
+[GitHub README's Citations section](https://github.com/lab-smile/FearConditioningAI#citations).
+
+---
+
+## License
+
+This model is released under the **MIT License**, matching the
+[GitHub repository](https://github.com/lab-smile/FearConditioningAI/blob/main/LICENSE).
+
+## Contact
+
+| Name | Email |
+|---|---|
+| Seowung Leem | leem.s@ufl.edu |
+| Dr. Ruogu Fang | ruogu.fang@bme.ufl.edu |

base_model_conditioned_orientation_epoch100.pth

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

base_model_vca_IAPS_quadrant.pth

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

config.json

@@ -0,0 +1,118 @@
+{
+  "architectures": ["Visual_Cortex_Amygdala"],
+  "model_type": "visual-valence-model",
+  "task": "image-valence-regression",
+  "source_repo": "https://github.com/lab-smile/FearConditioningAI",
+  "source_module": "models.VGG_Model",
+  "paper": "https://arxiv.org/abs/2607.19327",
+
+  "backbone": {
+    "name": "vgg16",
+    "pretrained_on": "imagenet-1k",
+    "batch_norm": false,
+    "frozen": true
+  },
+
+  "shortcut_pathway": {
+    "name": "middleroad",
+    "source_vgg_layer_index": 10,
+    "pooling": {
+      "middleroad_maxpool": {"kernel_size": 29, "stride": 14},
+      "global_maxpool_output_size": 2,
+      "maxpool1": {"kernel_size": 5, "stride": 3},
+      "maxpool2": {"kernel_size": 9, "stride": 5},
+      "maxpool3": {"kernel_size": 13, "stride": 7},
+      "adaptive_avgpool_output_sizes": [1, 2]
+    },
+    "attention": {
+      "type": "efficient_channel_attention",
+      "reference": "https://doi.org/10.1109/CVPR42600.2020.01155",
+      "conv1d_kernel_size": 3
+    },
+    "fc_layers": {
+      "input_size": 1024,
+      "hidden_sizes": [1024, 512],
+      "dropout": 0.5
+    }
+  },
+
+  "valence_module": {
+    "name": "VCA_FC",
+    "input_size": 4608,
+    "input_composition": {"highroad_features": 4096, "middleroad_features": 512},
+    "hidden_sizes": [1024, 1024],
+    "dropout": 0.5,
+    "output_size": 1,
+    "output_activation": "sigmoid",
+    "output_rescale_range": [1, 9],
+    "output_semantics": "valence rating (1 = extreme displeasure, 9 = extreme pleasure)"
+  },
+
+  "input": {
+    "image_size": 224,
+    "channels": 3,
+    "normalize_mean": [0.485, 0.456, 0.406],
+    "normalize_std": [0.229, 0.224, 0.225]
+  },
+
+  "checkpoints": {
+    "stage0_videoframe_pretrain": {
+      "filename": "vca_ckvideo_batch128_lr2e-5_epoch20.pth",
+      "stage": "Stage 0 (trained from scratch on Videoframe)",
+      "trained_on": ["Cowen & Keltner (2017) Videoframe"],
+      "input_layout": "full-frame (no quadrant cropping)",
+      "val_pearson_r": 0.386,
+      "val_mse": 0.043
+    },
+    "stage1_iaps_finetune": {
+      "filename": "vca_IAPS_batch10_lr2e-4_epoch23.pth",
+      "stage": "Stage 1 (fine-tuned on full-size IAPS)",
+      "trained_on": ["Cowen & Keltner (2017) Videoframe", "IAPS full-size"],
+      "input_layout": "full-frame (no quadrant cropping)",
+      "val_pearson_r": 0.538,
+      "val_mse": 0.192
+    },
+    "pre_conditioning": {
+      "filename": "base_model_vca_IAPS_quadrant.pth",
+      "stage": "Stage 2 (quadrant fine-tuning), before Pavlovian conditioning",
+      "trained_on": ["Cowen & Keltner (2017) Videoframe", "IAPS full-size", "IAPS quadrant-cropped"],
+      "input_layout": "quadrant-cropped (US in quadrant 4)",
+      "val_pearson_r": null,
+      "val_mse": null,
+      "note": "See paper for definitive evaluation numbers."
+    },
+    "post_conditioning_epoch1": {
+      "filename": "base_model_conditioned_orientation_epoch1.pth",
+      "stage": "Stage 3 (Pavlovian conditioning), epoch 1 of 100",
+      "trained_on": ["Cowen & Keltner (2017) Videoframe", "IAPS full-size", "IAPS quadrant-cropped", "IAPS Conditioning (US) x Gabor patch (CS)"],
+      "input_layout": "quadrant-cropped (CS in quadrant 2, US in quadrant 4)",
+      "val_pearson_r": 0.660,
+      "val_mse": 0.466,
+      "note": "Early/under-trained snapshot, kept for provenance; not representative of the final model."
+    },
+    "post_conditioning": {
+      "filename": "base_model_conditioned_orientation_epoch100.pth",
+      "stage": "Stage 3 (Pavlovian conditioning), epoch 100 (final, used in the paper)",
+      "trained_on": ["Cowen & Keltner (2017) Videoframe", "IAPS full-size", "IAPS quadrant-cropped", "IAPS Conditioning (US) x Gabor patch (CS)"],
+      "input_layout": "quadrant-cropped (CS in quadrant 2, US in quadrant 4)",
+      "val_pearson_r": null,
+      "val_mse": null,
+      "note": "See paper for definitive evaluation numbers.",
+      "conditioning_paradigm": {
+        "cs_stimulus": "Gabor patch (45 deg or 135 deg orientation)",
+        "us_stimulus": "IAPS image (unpleasant paired with 45 deg CS, pleasant paired with 135 deg CS)",
+        "cs_quadrant": 2,
+        "us_quadrant": 4
+      }
+    }
+  },
+
+  "checkpoint_format": {
+    "type": "torch.save dict",
+    "keys": ["model", "epoch", "best_per", "best_loss", "state_dict", "optimizer"],
+    "state_dict_key": "state_dict",
+    "note": "Load with model.load_state_dict(checkpoint['state_dict'], strict=False); the 'model' key is a pickled model object retained for reproducibility but should not be trusted/unpickled directly."
+  },
+
+  "license": "mit"
+}

inference_example.py

@@ -0,0 +1,152 @@
+"""Example inference script for the Visual-Valence Model (VCA).
+
+Requirements:
+    - Clone https://github.com/lab-smile/FearConditioningAI and run this script from
+      inside that repo (or add it to PYTHONPATH), so `models.VGG_Model` / `utils` are
+      importable. Install its dependencies (environment-<platform>.yml or requirements.txt).
+    - pip install huggingface_hub pillow torch torchvision
+
+Usage:
+    python inference_example.py --image path/to/scene.jpg --checkpoint post
+    python inference_example.py --gabor path/to/gabor_patch.png --checkpoint post
+    python inference_example.py --image path/to/scene.jpg --checkpoint stage1  # full-frame checkpoint
+
+Checkpoints (see CHECKPOINT_FILENAMES): stage0, stage1 (full-frame, Stages 0-1),
+pre, post_epoch1, post (quadrant-cropped, Stages 2-3).
+"""
+
+import argparse
+
+import torch
+from huggingface_hub import hf_hub_download
+from PIL import Image
+from torchvision import transforms
+
+from models.VGG_Model import Visual_Cortex_Amygdala
+
+# Placeholder — update to the actual Hugging Face repo id once uploaded.
+REPO_ID = "smilelab/visual-valence-model"
+
+CHECKPOINT_FILENAMES = {
+    "stage0": "vca_ckvideo_batch128_lr2e-5_epoch20.pth",  # trained from scratch on Videoframe
+    "stage1": "vca_IAPS_batch10_lr2e-4_epoch23.pth",  # fine-tuned on full-size IAPS
+    "pre": "base_model_vca_IAPS_quadrant.pth",  # Stage 2: quadrant fine-tune, before conditioning
+    "post_epoch1": "base_model_conditioned_orientation_epoch1.pth",  # Stage 3, epoch 1 (early snapshot)
+    "post": "base_model_conditioned_orientation_epoch100.pth",  # Stage 3, epoch 100 (final, after conditioning)
+}
+
+# Stage 0/1 checkpoints were trained on full-frame images; Stage 2/3 checkpoints expect the
+# quadrant-cropped layout (see preprocess_natural_image vs. preprocess_cs_only below).
+FULL_FRAME_CHECKPOINTS = {"stage0", "stage1"}
+
+IMAGE_SIZE = 224
+NORMALIZE_MEAN = [0.485, 0.456, 0.406]
+NORMALIZE_STD = [0.229, 0.224, 0.225]
+
+
+def load_model(checkpoint: str = "post", device: str = "cpu") -> torch.nn.Module:
+    """Download a checkpoint from the Hub and load it into a Visual_Cortex_Amygdala model."""
+    filename = CHECKPOINT_FILENAMES[checkpoint]
+    ckpt_path = hf_hub_download(repo_id=REPO_ID, filename=filename)
+
+    model = Visual_Cortex_Amygdala()
+    checkpoint_dict = torch.load(ckpt_path, map_location=device, weights_only=False)
+    model.load_state_dict(checkpoint_dict["state_dict"], strict=False)
+    model.to(device)
+    model.eval()
+    return model
+
+
+def preprocess_natural_image(image: Image.Image) -> torch.Tensor:
+    """Full-frame preprocessing for the Stage 0/1 checkpoints (no quadrant cropping)."""
+    transform = transforms.Compose([
+        transforms.Resize((IMAGE_SIZE, IMAGE_SIZE)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=NORMALIZE_MEAN, std=NORMALIZE_STD),
+    ])
+    return transform(image.convert("RGB")).unsqueeze(0)
+
+
+def _place_in_quadrant(patch: Image.Image, quadrant: int, canvas: Image.Image = None) -> Image.Image:
+    """Resize `patch` to quarter size and paste it into one quadrant of `canvas` (new blank one if None).
+
+    quadrant: 1 = top-right, 2 = top-left, 3 = bottom-left, 4 = bottom-right.
+    """
+    if canvas is None:
+        canvas = Image.new("RGB", (IMAGE_SIZE, IMAGE_SIZE))
+    patch = patch.convert("RGB").resize((IMAGE_SIZE // 2, IMAGE_SIZE // 2))
+    positions = {
+        1: (IMAGE_SIZE // 2, 0),
+        2: (0, 0),
+        3: (0, IMAGE_SIZE // 2),
+        4: (IMAGE_SIZE // 2, IMAGE_SIZE // 2),
+    }
+    canvas.paste(patch, positions[quadrant])
+    return canvas
+
+
+def preprocess_quadrant(image: Image.Image, quadrant: int = 4) -> torch.Tensor:
+    """Place a natural (US) scene alone into one quadrant of an otherwise-blank canvas.
+
+    Used for Stage 2/3 checkpoints, which were trained on quadrant-cropped US images
+    (see utils.Quadrant_Processing). Default quadrant 4 (bottom-right) matches training.
+    """
+    canvas = _place_in_quadrant(image, quadrant)
+    transform = transforms.Compose([
+        transforms.ToTensor(),
+        transforms.Normalize(mean=NORMALIZE_MEAN, std=NORMALIZE_STD),
+    ])
+    return transform(canvas).unsqueeze(0)
+
+
+def preprocess_cs_only(gabor_patch: Image.Image, quadrant: int = 2) -> torch.Tensor:
+    """Place a CS Gabor patch alone into one quadrant of an otherwise-blank canvas.
+
+    Mirrors the conditioning-stage input layout (see utils.Quadrant_Processing_Conditioning /
+    test_gaborpatches.py): the US quadrant is left blank so the response reflects only what
+    the model has learned to associate with the CS. Default quadrant 2 (top-left) matches
+    the CS placement used during Stage 3 training; only meaningful for Stage 2/3 checkpoints.
+    """
+    return preprocess_quadrant(gabor_patch, quadrant)
+
+
+@torch.no_grad()
+def predict_valence(model: torch.nn.Module, input_tensor: torch.Tensor, device: str = "cpu") -> float:
+    """Run the model and rescale its sigmoid output from [0, 1] to the [1, 9] IAPS valence scale."""
+    output = model(input_tensor.to(device))
+    valence = 1 + output.item() * (9 - 1)
+    return valence
+
+
+def main():
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--image", type=str, default=None, help="Path to a natural scene image (US-style input).")
+    parser.add_argument("--gabor", type=str, default=None, help="Path to a Gabor patch image (CS-only input).")
+    parser.add_argument("--checkpoint", choices=list(CHECKPOINT_FILENAMES), default="post",
+                        help="Which checkpoint to load (see CHECKPOINT_FILENAMES). Default: 'post' "
+                             "(final, post-conditioning model).")
+    parser.add_argument("--device", type=str, default="cpu")
+    args = parser.parse_args()
+
+    if not args.image and not args.gabor:
+        parser.error("Provide --image or --gabor.")
+    if args.gabor and args.checkpoint in FULL_FRAME_CHECKPOINTS:
+        parser.error(f"--gabor (CS-only input) isn't meaningful for checkpoint '{args.checkpoint}', "
+                     f"which was trained on full-frame images without a CS. Use --image instead, or "
+                     f"pick a Stage 2/3 checkpoint (pre, post_epoch1, post).")
+
+    model = load_model(checkpoint=args.checkpoint, device=args.device)
+
+    if args.image and args.checkpoint in FULL_FRAME_CHECKPOINTS:
+        input_tensor = preprocess_natural_image(Image.open(args.image))
+    elif args.image:
+        input_tensor = preprocess_quadrant(Image.open(args.image))
+    else:
+        input_tensor = preprocess_cs_only(Image.open(args.gabor))
+
+    valence = predict_valence(model, input_tensor, device=args.device)
+    print(f"Predicted valence (1=extreme displeasure, 9=extreme pleasure): {valence:.2f}")
+
+
+if __name__ == "__main__":
+    main()

vca_IAPS_batch10_lr2e-4_epoch23.pth

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

vca_ckvideo_batch128_lr2e-5_epoch20.pth

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