falseresmem 0.1.0__tar.gz

falseresmem-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anastasiia Mikhailova
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

falseresmem-0.1.0/MANIFEST.in

@@ -0,0 +1,2 @@
+global-exclude falseresmem/model.pt
+prune falseresmem/model.pt

falseresmem-0.1.0/PKG-INFO

@@ -0,0 +1,57 @@
+Metadata-Version: 2.4
+Name: falseresmem
+Version: 0.1.0
+Summary: A pip-installable PyTorch model package for False Image Memorability prediction.
+Author-email: Anastasiia Mikhailova <amikhailova@uchicago.edu>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Python: >=3.7
+Requires-Dist: pillow
+Requires-Dist: torch
+Requires-Dist: torchvision
+Description-Content-Type: text/markdown
+
+# FalseResMem Model Package
+
+A pip-installable Python package containing a custom PyTorch model (`FalseResMem`) for prediction of false alarms in visual memory recognition tasks.
+
+## Contact
+
+Author: Anastasiia Mikhailova  
+Email: amikhailova@uchicago.edu  
+
+## Installation
+
+You can install the package via pip from source (or PyPI once published):
+
+pip install .
+
+or
+
+pip install FalseResMem
+## Usage
+
+Here's a basic example of how to import and use the model after installation:
+
+**Low-level (raw tensors):**
+```python
+import torch
+from FalseResMem import load_model
+
+model = load_model()
+model.eval()
+input_tensor = torch.randn(1, 3, 224, 224)
+output = model(input_tensor)
+print(output)
+```
+
+**High-level (image file):**
+```python
+from FalseResMem import predict_image
+
+prob = predict_image("test.jpg").item()
+print(f"False alarm probability: {prob:.3f}")
+```
+
+## License
+MIT

falseresmem-0.1.0/README.md

@@ -0,0 +1,44 @@
+# FalseResMem Model Package
+
+A pip-installable Python package containing a custom PyTorch model (`FalseResMem`) for prediction of false alarms in visual memory recognition tasks.
+
+## Contact
+
+Author: Anastasiia Mikhailova  
+Email: amikhailova@uchicago.edu  
+
+## Installation
+
+You can install the package via pip from source (or PyPI once published):
+
+pip install .
+
+or
+
+pip install FalseResMem
+## Usage
+
+Here's a basic example of how to import and use the model after installation:
+
+**Low-level (raw tensors):**
+```python
+import torch
+from FalseResMem import load_model
+
+model = load_model()
+model.eval()
+input_tensor = torch.randn(1, 3, 224, 224)
+output = model(input_tensor)
+print(output)
+```
+
+**High-level (image file):**
+```python
+from FalseResMem import predict_image
+
+prob = predict_image("test.jpg").item()
+print(f"False alarm probability: {prob:.3f}")
+```
+
+## License
+MIT

falseresmem-0.1.0/falseresmem/__init__.py

@@ -0,0 +1,5 @@
+from .model import load_model
+from .inference import predict_image
+
+__version__ = "0.1.0"
+__all__ = ["predict_image", "load_model"]

falseresmem-0.1.0/falseresmem/inference.py

@@ -0,0 +1,24 @@
+import torch
+from .model import load_model
+from PIL import Image
+import torchvision.transforms as transforms
+
+def predict_image(image_path: str, device: str = "cpu") -> torch.Tensor:
+    """Predict false alarm probability from image path."""
+    model = load_model().to(device)
+    model.eval()
+    
+    transform = transforms.Compose([
+        transforms.Resize((256, 256)),
+        transforms.CenterCrop(227),
+        transforms.ToTensor()
+    ])
+
+    image = Image.open(image_path).convert("RGB")
+    input_tensor = transform(image).unsqueeze(0).to(device)
+    
+    with torch.no_grad():
+        output = model(input_tensor)
+    
+    return output 
+

falseresmem-0.1.0/falseresmem/model.py

@@ -0,0 +1,80 @@
+from torch import nn, cat
+from torchvision.models import resnet50, ResNet50_Weights
+import torch.nn.functional as F
+import torch
+import importlib.resources
+
+
+class FalseResMem(nn.Module):
+    def __init__(self, learning_rate=1e-5, momentum=.9, cruise_altitude=384):
+        super().__init__()
+        rn = list(resnet50(weights=ResNet50_Weights.DEFAULT).children())
+
+        self.features = nn.Sequential(*[rn[i] for i in range(9)])
+
+        self.conv1 = nn.Conv2d(3, 48, kernel_size=11, stride=4)
+        self.pool1 = nn.MaxPool2d(3, 2)
+        self.lrn1 = nn.LocalResponseNorm(5)
+        self.conv2 = nn.Conv2d(48, 256, kernel_size=5, stride=1, padding=2, groups=2)
+        self.pool2 = nn.MaxPool2d(3, 2)
+        self.lrn2 = nn.LocalResponseNorm(5)
+        self.conv3 = nn.Conv2d(256, cruise_altitude, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2)
+        self.conv4 = nn.Conv2d(cruise_altitude, cruise_altitude, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1),
+                               groups=2)
+        self.conv5 = nn.Conv2d(cruise_altitude, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), groups=2)
+        self.pool5 = nn.MaxPool2d(kernel_size=3, stride=2, padding=0, dilation=1, ceil_mode=False)
+
+        self.fc6 = nn.Linear(in_features=9216 + 2048, out_features=4096, bias=True)
+        self.drp6 = nn.Dropout(p=0.5, inplace=False)
+        self.fc7 = nn.Linear(in_features=4096, out_features=4096, bias=True)
+        self.drp7 = nn.Dropout(p=0.5, inplace=False)
+        self.fc8 = nn.Linear(in_features=4096, out_features=2048, bias=True)
+        self.drp8 = nn.Dropout(p=0.5, inplace=False)
+        self.fc9 = nn.Linear(in_features=2048, out_features=1024, bias=True)
+        self.drp9 = nn.Dropout(p=0.5, inplace=False)
+        self.fc10 = nn.Linear(in_features=1024, out_features=512, bias=True)
+        self.fc11 = nn.Linear(in_features=512, out_features=256, bias=True)
+        self.fc12 = nn.Linear(in_features=256, out_features=1, bias=True)
+
+    def forward(self, x):
+        cnv = F.relu(self.conv1(x))
+        cnv = self.pool1(cnv)
+        cnv = self.lrn1(cnv)
+        cnv = F.relu(self.conv2(cnv))
+        cnv = self.pool2(cnv)
+        cnv = self.lrn2(cnv)
+        cnv = F.relu(self.conv3(cnv))
+        cnv = F.relu(self.conv4(cnv))
+        cnv = F.relu(self.conv5(cnv))
+        cnv = self.pool5(cnv)
+        feat = cnv.view(-1, 9216)
+        resfeat = self.features(x).view(-1, 2048)
+
+        catfeat = cat((feat, resfeat), 1)
+
+        hid = F.relu(self.fc6(catfeat))
+        hid = self.drp6(hid)
+        hid = F.relu(self.fc7(hid))
+        hid = self.drp8(hid)
+        hid = F.relu(self.fc8(hid))
+        hid = self.drp9(hid)
+        hid = F.relu(self.fc9(hid))
+        hid = F.relu(self.fc10(hid))
+        hid = F.relu(self.fc11(hid))
+
+        pry = torch.sigmoid(self.fc12(hid))
+        return pry
+
+
+def load_model(device: str = "cpu") -> FalseResMem:
+    """Load pretrained FalseResMem model."""
+    model = FalseResMem().to(device)
+    model.eval()
+    
+    with importlib.resources.path("FalseResMem", "model.pt") as path:
+        checkpoint = torch.load(path, map_location=device, weights_only=False)
+        if isinstance(checkpoint, dict):
+            model.load_state_dict(checkpoint, strict=False)
+        else:
+            model.load_state_dict(checkpoint, strict=False)
+    return model

falseresmem-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "falseresmem"
+version = "0.1.0"
+description = "A pip-installable PyTorch model package for False Image Memorability prediction."
+readme = "README.md"
+requires-python = ">=3.7"
+license = "MIT"
+dependencies = ["torch", "torchvision", "pillow"]
+authors = [{name="Anastasiia Mikhailova", email="amikhailova@uchicago.edu"}]
+
+
+[tool.hatch.build.targets.wheel]
+exclude = ["/falseresmem/model.pt"]
+
+[tool.hatch.build.targets.sdist]
+exclude = ["/falseresmem/model.pt"]